Cut release 0.8.0

## Summary

* adds cyrillic glyphs to pixel arial font, used as Small font in UI

## Additional Context

* with recent changes pixel arial font lost cyrillic glyphs

.clangd

@@ -0,0 +1,2 @@
+CompileFlags:
+    Add: [-std=c++2a]

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: [daveallie]
+ko_fi: daveallie

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,54 @@
+name: Bug Report
+description: Report an issue or unexpected behavior
+title: "Short, descriptive title of the issue"
+labels: ["bug", "triage"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to report this bug! Please fill out the details below.
+
+  - type: input
+    id: version
+    attributes:
+      label: Affected Version
+      description: What version of the project/library are you using? (e.g., v1.2.3, master branch commit SHA)
+      placeholder: Ex. v1.2.3
+    validations:
+      required: true
+
+  - type: textarea
+    id: bug-description
+    attributes:
+      label: Describe the Bug
+      description: A clear and concise description of what the bug is.
+      placeholder:
+    validations:
+      required: true
+
+  - type: textarea
+    id: steps-to-reproduce
+    attributes:
+      label: Steps to Reproduce
+      description: Clearly list the steps necessary to reproduce the unexpected behavior.
+      placeholder: |
+        1. Go to '...'
+        2. Select '...'
+        3. Crash
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: Expected Behavior
+      description: A clear and concise description of what you expected to happen.
+    validations:
+      required: true
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant Log Output/Screenshots
+      description: If applicable, error messages, or log output to help explain your problem. You can drag and drop images here.
+      render: shell

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,9 @@
+## Summary
+
+* **What is the goal of this PR?** (e.g., Fixes a bug in the user authentication module, Implements the new feature for 
+  file uploading.)
+* **What changes are included?**
+
+## Additional Context
+
+* Add any other information that might be helpful for the reviewer (e.g., performance implications, potential risks, specific areas to focus on).

.github/workflows/ci.yml

@@ -0,0 +1,43 @@
+name: CI
+'on':
+  push:
+    branches: [master]
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          submodules: recursive
+      - uses: actions/cache@v5
+        with:
+          path: |
+            ~/.cache/pip
+            ~/.platformio/.cache
+          key: ${{ runner.os }}-pio
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.14'
+
+      - name: Install PlatformIO Core
+        run: pip install --upgrade platformio
+
+      - name: Install clang-format-21
+        run: |
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 21
+          sudo apt-get update
+          sudo apt-get install -y clang-format-21
+
+      - name: Run cppcheck
+        run: pio check --fail-on-defect low --fail-on-defect medium --fail-on-defect high
+
+      - name: Run clang-format
+        run: PATH="/usr/lib/llvm-21/bin:$PATH" ./bin/clang-format-fix && git diff --exit-code || (echo "Please run 'bin/clang-format-fix' to fix formatting issues" && exit 1)
+
+      - name: Build CrossPoint
+        run: pio run

.github/workflows/release.yml

@@ -0,0 +1,40 @@
+name: Compile Release
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  build-release:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          submodules: recursive
+      - uses: actions/cache@v5
+        with:
+          path: |
+            ~/.cache/pip
+            ~/.platformio/.cache
+          key: ${{ runner.os }}-pio
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.14'
+
+      - name: Install PlatformIO Core
+        run: pip install --upgrade platformio
+
+      - name: Build CrossPoint
+        run: pio run -e gh_release
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: CrossPoint-${{ github.ref_name }}
+          path: |
+            .pio/build/gh_release/bootloader.bin
+            .pio/build/gh_release/firmware.bin
+            .pio/build/gh_release/firmware.elf
+            .pio/build/gh_release/firmware.map
+            .pio/build/gh_release/partitions.bin

.gitignore

@@ -1,3 +1,6 @@
 .pio
 .idea
 .DS_Store
+.vscode
+lib/EpdFont/fontsrc
+*.generated.h

README.md

@@ -6,7 +6,7 @@ Built using **PlatformIO** and targeting the **ESP32-C3** microcontroller.
 CrossPoint Reader is a purpose-built firmware designed to be a drop-in, fully open-source replacement for the official 
 Xteink firmware. It aims to match or improve upon the standard EPUB reading experience.
 
-![](./docs/cover.jpg)
+![](./docs/images/cover.jpg)
 
 ## Motivation
 
@@ -23,20 +23,48 @@ CrossPoint Reader aims to:
 
 This project is **not affiliated with Xteink**; it's built as a community project.
 
-## Features
+## Features & Usage
 
 - [x] EPUB parsing and rendering
+- [ ] Image support within EPUB
 - [x] Saved reading position
-- [ ] File explorer with file picker
+- [x] File explorer with file picker
   - [x] Basic EPUB picker from root directory
   - [x] Support nested folders
   - [ ] EPUB picker with cover art
-- [ ] Image support within EPUB
+- [x] Custom sleep screen
+  - [ ] Cover sleep screen
+- [x] Wifi book upload
+- [ ] Wifi OTA updates
 - [ ] Configurable font, layout, and display options
-- [ ] WiFi connectivity
+- [ ] Screen rotation
-- [ ] BLE connectivity
 
-## Getting Started
+See [the user guide](./USER_GUIDE.md) for instructions on operating CrossPoint.
+
+## Installing
+
+### Web (latest firmware)
+
+1. Connect your Xteink X4 to your computer via USB-C
+2. Go to https://xteink.dve.al/ and click "Flash CrossPoint firmware"
+
+To revert back to the official firmware, you can flash the latest official firmware from https://xteink.dve.al/, or swap
+back to the other partition using the "Swap boot partition" button here https://xteink.dve.al/debug.
+
+### Web (specific firmware version)
+
+1. Connect your Xteink X4 to your computer via USB-C
+2. Download the `firmware.bin` file from the release of your choice via the [releases page](https://github.com/daveallie/crosspoint-reader/releases)
+3. Go to https://xteink.dve.al/ and flash the firmware file using the "OTA fast flash controls" section
+
+To revert back to the official firmware, you can flash the latest official firmware from https://xteink.dve.al/, or swap
+back to the other partition using the "Swap boot partition" button here https://xteink.dve.al/debug.
+
+### Manual
+
+See [Development](#development) below.
+
+## Development
 
 ### Prerequisites
 
@@ -58,24 +86,12 @@ git submodule update --init --recursive
 
 ### Flashing your device
 
-#### Command line
-
 Connect your Xteink X4 to your computer via USB-C and run the following command.
 
 ```sh
 pio run --target upload
 ```
 
-#### Web
-
-1. Connect your Xteink X4 to your computer via USB-C
-2. Download the `firmware.bin` file from the latest release via the [releases page](https://github.com/daveallie/crosspoint-reader/releases)
-3. Go to https://xteink.dve.al/ and flash the firmware file using the "OTA fast flash controls" section
-4. Press the reset button on the Xteink X4 to restart the device
-
-To revert back to the official firmware, you can flash the latest official firmware from https://xteink.dve.al/, or swap
-back to the other partition using the "Swap boot partition" button here https://xteink.dve.al/debug. 
-
 ## Internals
 
 CrossPoint Reader is pretty aggressive about caching data down to the SD card to minimise RAM usage. The ESP32-C3 only
@@ -116,6 +132,9 @@ EPUB file will reset the reading progress.
 
 Contributions are very welcome!
 
+If you're looking for a way to help out, take a look at the [ideas discussion board](https://github.com/daveallie/crosspoint-reader/discussions/categories/ideas).
+If there's something there you'd like to work on, leave a comment so that we can avoid duplicated effort.
+
 ### To submit a contribution:
 
 1. Fork the repo

USER_GUIDE.md

@@ -0,0 +1,127 @@
+# CrossPoint User Guide
+
+Welcome to the **CrossPoint** firmware. This guide outlines the hardware controls, navigation, and reading features of 
+the device.
+
+## 1. Hardware Overview
+
+The device utilises the standard buttons on the Xtink X4 in the same layout:
+
+### Button Layout
+| Location        | Buttons                                    |
+|-----------------|--------------------------------------------|
+| **Bottom Edge** | **Back**, **Confirm**, **Left**, **Right** |
+| **Right Side**  | **Power**, **Volume Up**, **Volume Down**  |
+
+---
+
+## 2. Power & Startup
+
+### Power On / Off
+
+To turn the device on or off, **press and hold the Power button for half a second**. In **Settings** you can configure
+the power button to trigger on a short press instead of a long one.
+
+### First Launch
+
+Upon turning the device on for the first time, you will be placed on the **Home** screen.
+
+> **Note:** On subsequent restarts, the firmware will automatically reopen the last book you were reading.
+
+---
+
+## 3. Screens
+
+### 3.1 Home Screen
+
+The Home Screen is the main entry point to the firmware. From here you can navigate to the **Book Selection** screen,
+**Settings** screen, or **File Upload** screen.
+
+### 3.2 Book Selection (Read)
+
+The Book Selection acts as a folder and file browser.
+
+* **Navigate List:** Use **Left** (or **Volume Up**), or **Right** (or **Volume Down**) to move the selection cursor up 
+  and down through folders and books.
+* **Open Selection:** Press **Confirm** to open a folder or read a selected book.
+
+### 3.3 Reading Screen
+
+See [4. Reading Mode](#4-reading-mode) below for more information.
+
+### 3.4 File Upload Screen
+
+The File Upload screen allows you to upload new e-books to the device. When you enter the screen you'll be prompted with
+a WiFi selection dialog and then your X4 will start hosting a web server.
+
+See the [webserver docs](./docs/webserver.md) for more information on how to connect to the web server and upload files.
+
+### 3.5 Settings
+
+The Settings screen allows you to configure the device's behavior. There are a few settings you can adjust:
+- **Sleep Screen**: Which sleep screen to display when the device sleeps, options are:
+  - "Dark" (default) - The default dark sleep screen
+  - "Light" - The same default sleep screen, on a white background
+  - "Custom" - Custom images from the SD card, see [3.6 Sleep Screen](#36-sleep-screen) below for more information
+  - "Cover" - The book cover image (Note: this is experimental and may not work as expected)
+- **Extra Paragraph Spacing**: If enabled, vertical space will be added between paragraphs in the book, if disabled,
+  paragraphs will not have vertical space between them, but will have first word indentation.
+- **Short Power Button Click**: Whether to trigger the power button on a short press or a long press.
+
+### 3.6 Sleep Screen
+
+You can customize the sleep screen by placing custom images in specific locations on the SD card:
+
+- **Single Image:** Place a file named `sleep.bmp` in the root directory.
+- **Multiple Images:** Create a `sleep` directory in the root of the SD card and place any number of `.bmp` images
+  inside. If images are found in this directory, they will take priority over the `sleep.png` file, and one will be
+  randomly selected each time the device sleeps.
+
+> [!NOTE]
+> You'll need to set the **Sleep Screen** setting to **Custom** in order to use these images.
+
+> [!TIP]
+> For best results:
+> - Use uncompressed BMP files with 24-bit color depth
+> - Use a resolution of 480x800 pixels to match the device's screen resolution.
+
+---
+
+## 4. Reading Mode
+
+Once you have opened a book, the button layout changes to facilitate reading.
+
+### Page Turning
+| Action            | Buttons                              |
+|-------------------|--------------------------------------|
+| **Previous Page** | Press **Left** _or_ **Volume Up**    |
+| **Next Page**     | Press **Right** _or_ **Volume Down** |
+
+### Chapter Navigation
+* **Next Chapter:** Press and **hold** the **Right** (or **Volume Down**) button briefly, then release.
+* **Previous Chapter:** Press and **hold** the **Left** (or **Volume Up**) button briefly, then release.
+
+### System Navigation
+* **Return to Home:** Press **Back** to close the book and return to the Book Selection screen.
+* **Chapter Menu:** Press **Confirm** to open the Table of Contents/Chapter Selection screen.
+
+---
+
+## 5. Chapter Selection Screen
+
+Accessible by pressing **Confirm** while inside a book.
+
+1.  Use **Left** (or **Volume Up**), or **Right** (or **Volume Down**) to highlight the desired chapter.
+2.  Press **Confirm** to jump to that chapter.
+3.  *Alternatively, press **Back** to cancel and return to your current page.*
+
+---
+
+## 6. Current Limitations & Roadmap
+
+Please note that this firmware is currently in active development. The following features are **not yet supported** but
+are planned for future updates:
+
+* **Images:** Embedded images in e-books will not render.
+* **Text Formatting:** There are currently no settings to adjust font type, size, line spacing, or margins.
+* **Rotation**: Different rotation options are not supported.

docs/comparison.md

@@ -0,0 +1,19 @@
+# CrossPoint vs XTOS
+
+Below is like for like comparison of CrossPoint (version 0.5.1) and XTOS (version 3.1.1). CrossPoint is on the left, 
+XTOS is on the right. CrossPoint does not currently support all features of XTOS, so this comparison is just of key 
+features which both firmwares support.
+
+## EPUB reading
+
+![](./images/comparison/reading-1.jpg)
+
+![](./images/comparison/reading-2.jpg)
+
+![](./images/comparison/reading-3.jpg)
+
+## Menus
+
+![](./images/comparison/menu.jpg)
+
+![](./images/comparison/chapter-menu.jpg)

docs/webserver.md

@@ -0,0 +1,272 @@
+# Web Server Guide
+
+This guide explains how to connect your CrossPoint Reader to WiFi and use the built-in web server to upload EPUB files from your computer or phone.
+
+## Overview
+
+CrossPoint Reader includes a built-in web server that allows you to:
+
+- Upload EPUB files wirelessly from any device on the same WiFi network
+- Browse and manage files on your device's SD card
+- Create folders to organize your ebooks
+- Delete files and folders
+
+## Prerequisites
+
+- Your CrossPoint Reader device
+- A WiFi network
+- A computer, phone, or tablet connected to the **same WiFi network**
+
+---
+
+## Step 1: Accessing the WiFi Screen
+
+1. From the main menu or file browser, navigate to the **Settings** screen
+2. Select the **WiFi** option
+3. The device will automatically start scanning for available networks
+
+---
+
+## Step 2: Connecting to WiFi
+
+### Viewing Available Networks
+
+Once the scan completes, you'll see a list of available WiFi networks with the following indicators:
+
+- **Signal strength bars** (`||||`, `|||`, `||`, `|`) - Shows connection quality
+- **`*` symbol** - Indicates the network is password-protected (encrypted)
+- **`+` symbol** - Indicates you have previously saved credentials for this network
+
+<img src="./images/wifi/wifi_networks.jpeg" height="500">
+
+### Selecting a Network
+
+1. Use the **Left/Right** (or **Volume Up/Down**) buttons to navigate through the network list
+2. Press **Confirm** to select the highlighted network
+
+### Entering Password (for encrypted networks)
+
+If the network requires a password:
+
+1. An on-screen keyboard will appear
+2. Use the navigation buttons to select characters
+3. Press **Confirm** to enter each character
+4. When complete, select the **Done** option on the keyboard
+
+<img src="./images/wifi/wifi_password.jpeg" height="500">
+
+**Note:** If you've previously connected to this network, the saved password will be used automatically.
+
+### Connection Process
+
+The device will display "Connecting..." while establishing the connection. This typically takes 5-10 seconds.
+
+### Saving Credentials
+
+If this is a new network, you'll be prompted to save the password:
+
+- Select **Yes** to save credentials for automatic connection next time (NOTE: These are stored in plaintext on the device's SD card. Do not use this for sensitive networks.)
+- Select **No** to connect without saving
+
+---
+
+## Step 3: Connection Success
+
+Once connected, the screen will display:
+
+- **Network name** (SSID)
+- **IP Address** (e.g., `192.168.1.102`)
+- **Web server URL** (e.g., `http://192.168.1.102/`)
+
+<img src="./images/wifi/wifi_connected.jpeg" height="500">
+
+**Important:** Make note of the IP address - you'll need this to access the web interface from your computer or phone.
+
+---
+
+## Step 4: Accessing the Web Interface
+
+### From a Computer
+
+1. Ensure your computer is connected to the **same WiFi network** as your CrossPoint Reader
+2. Open any web browser (Chrome is recommended)
+3. Type the IP address shown on your device into the browser's address bar
+   - Example: `http://192.168.1.102/`
+4. Press Enter
+
+### From a Phone or Tablet
+
+1. Ensure your phone/tablet is connected to the **same WiFi network** as your CrossPoint Reader
+2. Open your mobile browser (Safari, Chrome, etc.)
+3. Type the IP address into the address bar
+   - Example: `http://192.168.1.102/`
+4. Tap Go
+
+---
+
+## Step 5: Using the Web Interface
+
+### Home Page
+
+The home page displays:
+
+- Device status and version information
+- WiFi connection status
+- Current IP address
+- Available memory
+
+Navigation links:
+
+- **Home** - Returns to the status page
+- **File Manager** - Access file management features
+
+<img src="./images/wifi/webserver_homepage.png" width="600">
+
+### File Manager
+
+Click **File Manager** to access file management features.
+
+#### Browsing Files
+
+- The file manager displays all files and folders on your SD card
+- **Folders** are highlighted in yellow with a 📁 icon
+- **EPUB files** are highlighted in green with a 📗 icon
+- Click on a folder name to navigate into it
+- Use the breadcrumb navigation at the top to go back to parent folders
+
+<img src="./images/wifi/webserver_files.png" width="600">
+
+#### Uploading EPUB Files
+
+1. Click the **+ Add** button in the top-right corner
+2. Select **Upload eBook** from the dropdown menu
+3. Click **Choose File** and select an `.epub` file from your device
+4. Click **Upload**
+5. A progress bar will show the upload status
+6. The page will automatically refresh when the upload is complete
+
+**Note:** Only `.epub` files are accepted. Other file types will be rejected.
+
+<img src="./images/wifi/webserver_upload.png" width="600">
+
+#### Creating Folders
+
+1. Click the **+ Add** button in the top-right corner
+2. Select **New Folder** from the dropdown menu
+3. Enter a folder name (letters, numbers, underscores, and hyphens only)
+4. Click **Create Folder**
+
+This is useful for organizing your ebooks by genre, author, or series.
+
+#### Deleting Files and Folders
+
+1. Click the **🗑️** (trash) icon next to any file or folder
+2. Confirm the deletion in the popup dialog
+3. Click **Delete** to permanently remove the item
+
+**Warning:** Deletion is permanent and cannot be undone!
+
+**Note:** Folders must be empty before they can be deleted.
+
+---
+
+## Troubleshooting
+
+### Cannot See the Device on the Network
+
+**Problem:** Browser shows "Cannot connect" or "Site can't be reached"
+
+**Solutions:**
+
+1. Verify both devices are on the **same WiFi network**
+   - Check your computer/phone WiFi settings
+   - Confirm the CrossPoint Reader shows "Connected" status
+2. Double-check the IP address
+   - Make sure you typed it correctly
+   - Include `http://` at the beginning
+3. Try disabling VPN if you're using one
+4. Some networks have "client isolation" enabled - check with your network administrator
+
+### Connection Drops or Times Out
+
+**Problem:** WiFi connection is unstable
+
+**Solutions:**
+
+1. Move closer to the WiFi router
+2. Check signal strength on the device (should be at least `||` or better)
+3. Avoid interference from other devices
+4. Try a different WiFi network if available
+
+### Upload Fails
+
+**Problem:** File upload doesn't complete or shows an error
+
+**Solutions:**
+
+1. Ensure the file is a valid `.epub` file
+2. Check that the SD card has enough free space
+3. Try uploading a smaller file first to test
+4. Refresh the browser page and try again
+
+### Saved Password Not Working
+
+**Problem:** Device fails to connect with saved credentials
+
+**Solutions:**
+
+1. When connection fails, you'll be prompted to "Forget Network"
+2. Select **Yes** to remove the saved password
+3. Reconnect and enter the password again
+4. Choose to save the new password
+
+---
+
+## Security Notes
+
+- The web server runs on port 80 (standard HTTP)
+- **No authentication is required** - anyone on the same network can access the interface
+- The web server is only accessible while the WiFi screen shows "Connected"
+- The web server automatically stops when you exit the WiFi screen
+- For security, only use on trusted private networks
+
+---
+
+## Technical Details
+
+- **Supported WiFi:** 2.4GHz networks (802.11 b/g/n)
+- **Web Server Port:** 80 (HTTP)
+- **Maximum Upload Size:** Limited by available SD card space
+- **Supported File Format:** `.epub` only
+- **Browser Compatibility:** All modern browsers (Chrome, Firefox, Safari, Edge)
+
+---
+
+## Tips and Best Practices
+
+1. **Organize with folders** - Create folders before uploading to keep your library organized
+2. **Check signal strength** - Stronger signals (`|||` or `||||`) provide faster, more reliable uploads
+3. **Upload multiple files** - You can upload files one at a time; the page refreshes after each upload
+4. **Use descriptive names** - Name your folders clearly (e.g., "SciFi", "Mystery", "Non-Fiction")
+5. **Keep credentials saved** - Save your WiFi password for quick reconnection in the future
+6. **Exit when done** - Press **Back** to exit the WiFi screen and save battery
+
+---
+
+## Exiting WiFi Mode
+
+When you're finished uploading files:
+
+1. Press the **Back** button on your CrossPoint Reader
+2. The web server will automatically stop
+3. WiFi will disconnect to conserve battery
+4. You'll return to the previous screen
+
+Your uploaded files will be immediately available in the file browser!
+
+---
+
+## Related Documentation
+
+- [User Guide](../USER_GUIDE.md) - General device operation
+- [README](../README.md) - Project overview and features

lib/EpdFont/EpdFontData.h

@@ -31,4 +31,5 @@ typedef struct {
   uint8_t advanceY;                     ///< Newline distance (y axis)
   int ascender;                         ///< Maximal height of a glyph above the base line
   int descender;                        ///< Maximal height of a glyph below the base line
+  bool is2Bit;
 } EpdFontData;

lib/EpdFont/builtinFonts/babyblue.h

@@ -1,504 +0,0 @@
-/**
- * generated by fontconvert.py
- * name: babyblue
- * size: 8
- */
-#pragma once
-#include "EpdFontData.h"
-
-static const uint8_t babyblueBitmaps[3140] = {
-    0xFF, 0xFF, 0x30, 0xFF, 0xFF, 0xF0, 0x36, 0x1B, 0x0D, 0x9F, 0xFF, 0xF9, 0xB3, 0xFF, 0xFF, 0x36, 0x1B, 0x0D, 0x80,
-    0x18, 0x18, 0x7E, 0xFF, 0xDB, 0xD8, 0xFE, 0x7F, 0x9B, 0xDB, 0xFF, 0x7E, 0x18, 0x00, 0x71, 0x9F, 0x73, 0x6C, 0x6F,
-    0x8F, 0xE0, 0xFF, 0x83, 0xF8, 0xFB, 0x1B, 0x63, 0x7C, 0xC7, 0x00, 0x38, 0x3E, 0x1B, 0x0D, 0x87, 0xC3, 0xEF, 0xBF,
-    0x8E, 0xCF, 0x7F, 0x1E, 0xC0, 0xFF, 0x37, 0xEC, 0xCC, 0xCC, 0xCC, 0xCC, 0x67, 0x20, 0xCE, 0x73, 0x33, 0x33, 0x33,
-    0x33, 0x6C, 0x80, 0x32, 0xFF, 0xDE, 0xFE, 0x30, 0x18, 0x18, 0x18, 0xFF, 0xFF, 0x18, 0x18, 0x18, 0xBF, 0x00, 0xFF,
-    0xC0, 0x30, 0x0C, 0x31, 0xC6, 0x18, 0xE3, 0x1C, 0x63, 0x8C, 0x00, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
-    0xC7, 0x7E, 0x3C, 0x19, 0xDF, 0xFD, 0x8C, 0x63, 0x18, 0xC6, 0x3C, 0x7E, 0xE7, 0x83, 0x07, 0x0E, 0x1C, 0x38, 0x70,
-    0xFE, 0xFF, 0x7E, 0xFF, 0xC3, 0x07, 0x3E, 0x3E, 0x07, 0x03, 0x83, 0xFF, 0x7E, 0x0E, 0x1E, 0x3E, 0x76, 0xE6, 0xFF,
-    0xFF, 0x06, 0x06, 0x06, 0x06, 0x7F, 0xFF, 0x06, 0x0F, 0xDF, 0xC1, 0x83, 0x87, 0xFD, 0xF0, 0x3E, 0x7F, 0xE3, 0xC0,
-    0xFC, 0xFE, 0xE7, 0xC3, 0xC7, 0x7E, 0x3C, 0xFF, 0xFF, 0xC0, 0xE0, 0xE0, 0x60, 0x70, 0x30, 0x18, 0x1C, 0x0C, 0x06,
-    0x00, 0x3C, 0x7E, 0x66, 0x66, 0x7E, 0x7E, 0xE7, 0xC3, 0xC7, 0x7E, 0x3C, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7, 0x7F,
-    0x3F, 0x07, 0x3E, 0x7C, 0xB0, 0x03, 0xB0, 0x03, 0xF8, 0x06, 0x3D, 0xF7, 0x8F, 0x0F, 0x87, 0x03, 0xFF, 0xFF, 0x00,
-    0xFF, 0xFF, 0x81, 0xE1, 0xF0, 0xF1, 0xEF, 0xBC, 0x40, 0x38, 0xFB, 0xBE, 0x30, 0xE3, 0x8E, 0x18, 0x30, 0x00, 0xC0,
-    0x0F, 0xE0, 0x7F, 0xC3, 0x83, 0x9D, 0xE7, 0xEF, 0xCF, 0x73, 0x3D, 0x8C, 0xF6, 0x33, 0xD8, 0xDB, 0x3F, 0xC6, 0x7E,
-    0x0C, 0x03, 0x18, 0x18, 0x7F, 0xE0, 0xFF, 0x00, 0x38, 0xFB, 0xBE, 0x3C, 0x7F, 0xFF, 0xE3, 0xC7, 0x8C, 0xFC, 0xFE,
-    0xC7, 0xC7, 0xFE, 0xFE, 0xC7, 0xC7, 0xFE, 0xFC, 0x3F, 0x3F, 0xF8, 0x78, 0x0C, 0x06, 0x03, 0x01, 0x83, 0x7F, 0x9F,
-    0x80, 0xFC, 0xFE, 0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFE, 0xFC, 0xFF, 0xFF, 0x06, 0x0F, 0xDF, 0xB0, 0x60, 0xFD,
-    0xFC, 0xFF, 0xFF, 0x06, 0x0F, 0xDF, 0xB0, 0x60, 0xC1, 0x80, 0x3F, 0x3F, 0xF8, 0x78, 0x0C, 0x7E, 0x3F, 0x07, 0x83,
-    0x7F, 0x9F, 0x80, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xF0, 0x0C, 0x30, 0xC3,
-    0x0C, 0x38, 0xF3, 0xFD, 0xE0, 0xC3, 0xC7, 0xCE, 0xDC, 0xF8, 0xF8, 0xDC, 0xCC, 0xC6, 0xC3, 0xC1, 0x83, 0x06, 0x0C,
-    0x18, 0x30, 0x60, 0xFD, 0xFC, 0xE1, 0xF8, 0x7F, 0x3F, 0xCF, 0xFF, 0xF7, 0xBD, 0xEF, 0x7B, 0xCC, 0xF3, 0x30, 0xC3,
-    0xE3, 0xF3, 0xF3, 0xFB, 0xDF, 0xCF, 0xCF, 0xC7, 0xC3, 0x3E, 0x3F, 0xB8, 0xF8, 0x3C, 0x1E, 0x0F, 0x07, 0x87, 0x7F,
-    0x1F, 0x00, 0xFE, 0xFF, 0xC3, 0xC3, 0xFF, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0x3E, 0x3F, 0xB8, 0xF8, 0x3C, 0x1E, 0x0F,
-    0x37, 0x9F, 0x7F, 0x1F, 0xC0, 0xFE, 0xFF, 0xC3, 0xC7, 0xFE, 0xFE, 0xC7, 0xC3, 0xC3, 0xC3, 0x7D, 0xFF, 0x1F, 0x87,
-    0xC3, 0xC1, 0xC3, 0xFE, 0xF8, 0xFF, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xC3, 0xC3, 0xC3, 0xC3,
-    0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0xC3, 0xC3, 0xC3, 0xE7, 0x66, 0x7E, 0x3C, 0x3C, 0x3C, 0x18, 0x83, 0x0F, 0x0C,
-    0x3C, 0x30, 0xF1, 0xE7, 0x67, 0x99, 0xBF, 0xE3, 0xCF, 0x0F, 0x3C, 0x3C, 0xF0, 0x61, 0x80, 0x80, 0xF8, 0x77, 0x38,
-    0xFC, 0x1E, 0x07, 0x83, 0xF1, 0xCE, 0xE1, 0xB0, 0x30, 0xC3, 0xC3, 0xE7, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0xFF, 0xFF, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0, 0xFE, 0xFF, 0xFF, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xFE, 0x81, 0xC1,
-    0x83, 0x83, 0x83, 0x06, 0x06, 0x0C, 0x0C, 0xFF, 0x33, 0x33, 0x33, 0x33, 0x33, 0xFE, 0x18, 0x3C, 0x7E, 0x66, 0xE7,
-    0xC3, 0x83, 0xFF, 0xFF, 0x9D, 0x80, 0x7D, 0xFE, 0x1B, 0xFF, 0xF8, 0xFF, 0xBF, 0xC1, 0x83, 0xE7, 0xEC, 0xF8, 0xF1,
-    0xE7, 0xFD, 0xF0, 0x3C, 0xFF, 0x9E, 0x0C, 0x18, 0x9F, 0x9E, 0x06, 0x0C, 0xFB, 0xFE, 0x78, 0xF1, 0xE3, 0x7E, 0x7C,
-    0x3C, 0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x3B, 0xD9, 0xFF, 0xB1, 0x8C, 0x63, 0x18, 0x3E, 0xFF, 0x9E, 0x3C,
-    0x78, 0xDF, 0x9F, 0x06, 0x0D, 0xF3, 0xC0, 0xC3, 0x0F, 0xBF, 0xEF, 0x3C, 0xF3, 0xCF, 0x30, 0xFB, 0xFF, 0xF0, 0x6D,
-    0x36, 0xDB, 0x6D, 0xBD, 0x00, 0xC3, 0x0C, 0xF7, 0xFB, 0xCE, 0x3C, 0xDB, 0x30, 0xFF, 0xFF, 0xF0, 0x7F, 0xBF, 0xFC,
-    0xCF, 0x33, 0xCC, 0xF3, 0x3C, 0xCF, 0x33, 0x7B, 0xFC, 0xF3, 0xCF, 0x3C, 0xF3, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7,
-    0x7E, 0x3C, 0x79, 0xFB, 0x3E, 0x3C, 0x79, 0xFF, 0x7C, 0xC1, 0x82, 0x00, 0x3C, 0xFF, 0x9E, 0x3C, 0x78, 0xDF, 0x9F,
-    0x06, 0x0C, 0x10, 0x77, 0xF7, 0x8C, 0x63, 0x18, 0x7D, 0xFF, 0x1F, 0xE7, 0xF0, 0xFF, 0xBE, 0x63, 0x3D, 0xE6, 0x31,
-    0x8C, 0x71, 0xC0, 0x8F, 0x3C, 0xF3, 0xCF, 0x3F, 0xDE, 0x83, 0xC3, 0xC7, 0x66, 0x66, 0x6E, 0x3C, 0x18, 0x80, 0xF3,
-    0x3D, 0xFD, 0xFE, 0x7F, 0x9F, 0xE3, 0x30, 0xCC, 0x83, 0xC7, 0x6E, 0x3C, 0x38, 0x7C, 0xE6, 0xC3, 0x83, 0xC7, 0x66,
-    0x6E, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x70, 0x60, 0xFF, 0xFC, 0x71, 0xC7, 0x1C, 0x3F, 0x7F, 0x19, 0xCC, 0x63, 0x3B,
-    0x98, 0x61, 0x8C, 0x63, 0x1C, 0x40, 0xFF, 0xFF, 0xFF, 0xF8, 0x83, 0x87, 0x0C, 0x30, 0xE1, 0xC7, 0x38, 0xC3, 0x0C,
-    0x63, 0x08, 0x00, 0x79, 0xFF, 0xE3, 0xC0, 0xF2, 0xFF, 0xFE, 0x18, 0x30, 0xF3, 0xFF, 0xFB, 0x36, 0x6E, 0x7E, 0x78,
-    0x60, 0xC1, 0x00, 0x3C, 0x7E, 0x66, 0x60, 0xFC, 0xFC, 0x30, 0x72, 0xFF, 0xFE, 0x83, 0xFF, 0x7E, 0x66, 0x66, 0x7E,
-    0xFE, 0x83, 0x83, 0xE7, 0x7E, 0x3C, 0xFF, 0xFF, 0xFF, 0xFF, 0x18, 0x18, 0xFF, 0xFC, 0xBF, 0xF8, 0x3C, 0x7E, 0x66,
-    0x7E, 0x7C, 0xEE, 0xC7, 0xC3, 0x77, 0x3E, 0x0C, 0x66, 0x66, 0x7C, 0x38, 0x9E, 0xE6, 0x3F, 0x1F, 0xEF, 0xFF, 0xFF,
-    0xF3, 0xFC, 0x3F, 0x3F, 0xFF, 0xDF, 0xDF, 0xE3, 0xF0, 0x77, 0xFF, 0xFF, 0xBC, 0x36, 0xFF, 0xF6, 0xCD, 0xCD, 0x8D,
-    0x80, 0xFF, 0xFF, 0x03, 0x03, 0x03, 0x3F, 0x1F, 0xEF, 0xFF, 0xFB, 0xF6, 0xFF, 0xBF, 0xEF, 0xDB, 0xF7, 0xDF, 0xE3,
-    0xF0, 0xFF, 0xFF, 0x6F, 0xFF, 0x60, 0x18, 0x18, 0x18, 0xFF, 0xFF, 0x18, 0x18, 0xFE, 0xFF, 0x77, 0xE6, 0x77, 0x73,
-    0xFF, 0x77, 0xEF, 0x7F, 0xB8, 0x7F, 0x00, 0xCF, 0x3C, 0xF3, 0xCF, 0x3F, 0xFE, 0xC3, 0x0C, 0x20, 0x7F, 0xFF, 0xFE,
-    0xFE, 0xFE, 0x7E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x16, 0xB0, 0x63, 0xEC, 0x37, 0xFB, 0x33, 0x30, 0x7B,
-    0xFC, 0xF3, 0xFD, 0xE0, 0x99, 0xF9, 0xF9, 0xB7, 0xFF, 0xB6, 0x00, 0x30, 0x07, 0x03, 0xF0, 0x7B, 0x0E, 0x31, 0xC3,
-    0x38, 0x37, 0x60, 0xEE, 0x1D, 0xE3, 0xBF, 0x33, 0xF6, 0x06, 0x30, 0x67, 0x0E, 0xF1, 0xCB, 0x38, 0x37, 0x03, 0xEF,
-    0x1D, 0xF3, 0x9F, 0x70, 0xEE, 0x0E, 0xC1, 0xF0, 0x70, 0x6F, 0x8E, 0xB9, 0xCB, 0xB8, 0xFF, 0x07, 0xE6, 0x1C, 0xE3,
-    0x9E, 0x73, 0xFE, 0x3F, 0xC0, 0x60, 0x30, 0x60, 0xC1, 0x87, 0x1C, 0x30, 0x60, 0xC6, 0xD9, 0xE1, 0x80, 0x30, 0x70,
-    0x61, 0xC7, 0xDD, 0xF1, 0xE3, 0xFF, 0xFF, 0x1E, 0x3C, 0x60, 0x18, 0x70, 0xC1, 0xC7, 0xDD, 0xF1, 0xE3, 0xFF, 0xFF,
-    0x1E, 0x3C, 0x60, 0x38, 0xF9, 0xB1, 0xC7, 0xDD, 0xF1, 0xE3, 0xFF, 0xFF, 0x1E, 0x3C, 0x60, 0x3C, 0xF9, 0xE1, 0xC7,
-    0xDD, 0xF1, 0xE3, 0xFF, 0xFF, 0x1E, 0x3C, 0x60, 0x6C, 0xD8, 0xE3, 0xEE, 0xF8, 0xF1, 0xFF, 0xFF, 0x8F, 0x1E, 0x30,
-    0x38, 0xF9, 0xF1, 0xC7, 0xDD, 0xF1, 0xE3, 0xFF, 0xFF, 0x1E, 0x3C, 0x60, 0x0F, 0xF8, 0x7F, 0xC7, 0xC0, 0x36, 0x03,
-    0xB0, 0x19, 0xF9, 0xFF, 0xCF, 0xE0, 0xE3, 0x06, 0x1F, 0xB0, 0xFE, 0x3F, 0x3F, 0xF8, 0x78, 0x0C, 0x06, 0x03, 0x01,
-    0x83, 0x7F, 0x9F, 0x86, 0x01, 0x83, 0x81, 0x80, 0x30, 0x70, 0x67, 0xFF, 0xF8, 0x30, 0x7E, 0xFD, 0x83, 0x07, 0xEF,
-    0xE0, 0x0C, 0x38, 0x67, 0xFF, 0xF8, 0x30, 0x7E, 0xFD, 0x83, 0x07, 0xEF, 0xE0, 0x18, 0x78, 0xF7, 0xFF, 0xF8, 0x30,
-    0x7E, 0xFD, 0x83, 0x07, 0xEF, 0xE0, 0x3C, 0x7B, 0xFF, 0xFC, 0x18, 0x3F, 0x7E, 0xC1, 0x83, 0xF7, 0xF0, 0x9D, 0x36,
-    0xDB, 0x6D, 0xB6, 0x7A, 0x6D, 0xB6, 0xDB, 0x6C, 0x6F, 0xB6, 0x66, 0x66, 0x66, 0x66, 0x60, 0xBB, 0x66, 0x66, 0x66,
-    0x66, 0x66, 0x7E, 0x3F, 0x98, 0xEC, 0x3F, 0xDF, 0xED, 0x86, 0xC7, 0x7F, 0x3F, 0x00, 0x1E, 0x3E, 0x3C, 0xC3, 0xE3,
-    0xF3, 0xF3, 0xFB, 0xDF, 0xCF, 0xCF, 0xC7, 0xC3, 0x18, 0x0E, 0x03, 0x07, 0xC7, 0xF7, 0x1F, 0x07, 0x83, 0xC1, 0xE0,
-    0xF0, 0xEF, 0xE3, 0xE0, 0x0C, 0x0E, 0x06, 0x07, 0xC7, 0xF7, 0x1F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0xEF, 0xE3, 0xE0,
-    0x1C, 0x1F, 0x0D, 0x87, 0xC7, 0xF7, 0x1F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0xEF, 0xE3, 0xE0, 0x1E, 0x1F, 0x0F, 0x07,
-    0xC7, 0xF7, 0x1F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0xEF, 0xE3, 0xE0, 0x36, 0x1B, 0x0F, 0x8F, 0xEE, 0x3E, 0x0F, 0x07,
-    0x83, 0xC1, 0xE1, 0xDF, 0xC7, 0xC0, 0x8F, 0xF7, 0x9E, 0xFF, 0x30, 0x1F, 0xCF, 0xF7, 0x3D, 0x9F, 0x6E, 0xDF, 0x37,
-    0x8D, 0xC7, 0xFF, 0xB7, 0xC0, 0x30, 0x38, 0x18, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x0C,
-    0x1C, 0x18, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x18, 0x3C, 0x3C, 0xC3, 0xC3, 0xC3, 0xC3,
-    0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x3C, 0x3C, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x0C,
-    0x1C, 0x18, 0xC3, 0xC3, 0xE7, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0xC0, 0xFC, 0xFE, 0xC7, 0xC3, 0xC7, 0xFE,
-    0xFC, 0xC0, 0xC0, 0x38, 0xFB, 0xB6, 0x6D, 0xDB, 0x37, 0x67, 0xE7, 0xFF, 0x70, 0x30, 0x70, 0x63, 0xEF, 0xF0, 0xDF,
-    0xFF, 0xC7, 0xFD, 0xF8, 0x0C, 0x38, 0x63, 0xEF, 0xF0, 0xDF, 0xFF, 0xC7, 0xFD, 0xF8, 0x18, 0x78, 0xF3, 0xEF, 0xF0,
-    0xDF, 0xFF, 0xC7, 0xFD, 0xF8, 0x3C, 0xF9, 0xE3, 0xEF, 0xF0, 0xDF, 0xFF, 0xC7, 0xFD, 0xF8, 0x3C, 0x79, 0xF7, 0xF8,
-    0x6F, 0xFF, 0xE3, 0xFE, 0xFC, 0x18, 0x78, 0xF0, 0xC7, 0xDF, 0xE1, 0xBF, 0xFF, 0x8F, 0xFB, 0xF0, 0x7F, 0xEF, 0xFF,
-    0x86, 0x37, 0xFF, 0xFF, 0xFC, 0x61, 0xFF, 0xF7, 0xFE, 0x3C, 0xFF, 0x9E, 0x0C, 0x18, 0x9F, 0x9E, 0x18, 0x18, 0xE1,
-    0x80, 0x30, 0x38, 0x18, 0x3C, 0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x0C, 0x1C, 0x18, 0x3C, 0x7E, 0xE7, 0xFF,
-    0xFF, 0xC0, 0x7E, 0x3F, 0x18, 0x3C, 0x3C, 0x3C, 0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x3C, 0x3C, 0x3C, 0x7E,
-    0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x9D, 0xA6, 0xDB, 0x6D, 0x80, 0x7F, 0x4D, 0xB6, 0xDB, 0x00, 0x6F, 0xB4, 0x66,
-    0x66, 0x66, 0x60, 0xBB, 0x46, 0x66, 0x66, 0x66, 0x3E, 0x3E, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C,
-    0x3D, 0xF7, 0x9E, 0xFF, 0x3C, 0xF3, 0xCF, 0x3C, 0xC0, 0x30, 0x38, 0x18, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7, 0x7E,
-    0x3C, 0x0C, 0x1C, 0x18, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x18, 0x3C, 0x3C, 0x3C, 0x7E, 0xE7, 0xC3,
-    0xC3, 0xC7, 0x7E, 0x3C, 0x1E, 0x3E, 0x3C, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x3C, 0x3C, 0x3C, 0x7E,
-    0xE7, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x18, 0x18, 0xFF, 0xFF, 0x10, 0x18, 0x3F, 0x7F, 0xEF, 0xDF, 0xFB, 0xF7, 0xFE,
-    0xFC, 0x61, 0xC3, 0x23, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80, 0x18, 0xE3, 0x23, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80,
-    0x31, 0xE7, 0xA3, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80, 0x79, 0xE8, 0xF3, 0xCF, 0x3C, 0xF3, 0xFD, 0xE0, 0x0C, 0x1C,
-    0x18, 0x83, 0xC7, 0x66, 0x6E, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x70, 0x60, 0xC1, 0x83, 0xE7, 0xEE, 0xF8, 0xF1, 0xE7,
-    0xFD, 0xF3, 0x06, 0x08, 0x00, 0x3C, 0x3C, 0x83, 0xC7, 0x66, 0x6E, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x70, 0x60, 0x7C,
-    0xF8, 0xE3, 0xEE, 0xF8, 0xF1, 0xFF, 0xFF, 0x8F, 0x1E, 0x30, 0x7C, 0xF9, 0xF7, 0xF8, 0x6F, 0xFF, 0xE3, 0xFE, 0xFC,
-    0x6C, 0xF8, 0xE1, 0xC7, 0xDD, 0xF1, 0xE3, 0xFF, 0xFF, 0x1E, 0x3C, 0x60, 0x6C, 0xF8, 0xE3, 0xEF, 0xF0, 0xDF, 0xFF,
-    0xC7, 0xFD, 0xF8, 0x38, 0x7C, 0xEE, 0xC6, 0xC6, 0xFE, 0xFE, 0xC6, 0xC6, 0xC6, 0x0C, 0x0C, 0x0F, 0x07, 0x7C, 0xFE,
-    0x86, 0x7E, 0xFE, 0xC6, 0xFE, 0x7E, 0x06, 0x0C, 0x0F, 0x0F, 0x0C, 0x0E, 0x06, 0x07, 0xE7, 0xFF, 0x0F, 0x01, 0x80,
-    0xC0, 0x60, 0x30, 0x6F, 0xF3, 0xF0, 0x0C, 0x38, 0x61, 0xE7, 0xFC, 0xF0, 0x60, 0xC4, 0xFC, 0xF0, 0x0C, 0x0F, 0x07,
-    0x87, 0xE7, 0xFF, 0x0F, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x6F, 0xF3, 0xF0, 0x18, 0x78, 0xF1, 0xE7, 0xFC, 0xF0, 0x60,
-    0xC4, 0xFC, 0xF0, 0x0C, 0x06, 0x0F, 0xCF, 0xFE, 0x1E, 0x03, 0x01, 0x80, 0xC0, 0x60, 0xDF, 0xE7, 0xE0, 0x18, 0x30,
-    0xF3, 0xFE, 0x78, 0x30, 0x62, 0x7E, 0x78, 0x1E, 0x0F, 0x03, 0x07, 0xE7, 0xFF, 0x0F, 0x01, 0x80, 0xC0, 0x60, 0x30,
-    0x6F, 0xF3, 0xF0, 0x3C, 0x78, 0x61, 0xE7, 0xFC, 0xF0, 0x60, 0xC4, 0xFC, 0xF0, 0x78, 0x78, 0x30, 0xFC, 0xFE, 0xC7,
-    0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFE, 0xFC, 0x01, 0x83, 0xC1, 0xE7, 0xC7, 0xE7, 0x33, 0x19, 0x8C, 0xC6, 0x3F, 0x0F,
-    0x80, 0x7E, 0x3F, 0x98, 0xEC, 0x3F, 0xDF, 0xED, 0x86, 0xC7, 0x7F, 0x3F, 0x00, 0x06, 0x1F, 0x1F, 0x3E, 0x7E, 0xE6,
-    0xC6, 0xC6, 0xC6, 0x7E, 0x3E, 0x3C, 0x7B, 0xFF, 0xFC, 0x18, 0x3F, 0x7E, 0xC1, 0x83, 0xF7, 0xF0, 0x3C, 0x3C, 0x3C,
-    0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x66, 0xFC, 0xF7, 0xFF, 0xF8, 0x30, 0x7E, 0xFD, 0x83, 0x07, 0xEF, 0xE0,
-    0x66, 0x7E, 0x3C, 0x3C, 0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x18, 0x33, 0xFF, 0xFC, 0x18, 0x3F, 0x7E, 0xC1,
-    0x83, 0xF7, 0xF0, 0x18, 0x18, 0x3C, 0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0xFE, 0xFE, 0xC0, 0xC0, 0xFC, 0xFC,
-    0xC0, 0xC0, 0xFC, 0xFE, 0x06, 0x0C, 0x0F, 0x0F, 0x3C, 0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x06, 0x0C, 0x0F,
-    0x07, 0x3C, 0x78, 0x67, 0xFF, 0xF8, 0x30, 0x7E, 0xFD, 0x83, 0x07, 0xEF, 0xE0, 0x3C, 0x3C, 0x18, 0x3C, 0x7E, 0xE7,
-    0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x0C, 0x0F, 0x07, 0x87, 0xE7, 0xFF, 0x0F, 0x01, 0x8F, 0xC7, 0xE0, 0xF0, 0x6F, 0xF3,
-    0xF0, 0x18, 0x78, 0xF1, 0xF7, 0xFC, 0xF1, 0xE3, 0xC6, 0xFC, 0xF8, 0x30, 0x6F, 0x9E, 0x00, 0x36, 0x1F, 0x07, 0x07,
-    0xE7, 0xFF, 0x0F, 0x01, 0x8F, 0xC7, 0xE0, 0xF0, 0x6F, 0xF3, 0xF0, 0x36, 0x7C, 0x71, 0xF7, 0xFC, 0xF1, 0xE3, 0xC6,
-    0xFC, 0xF8, 0x30, 0x6F, 0x9E, 0x00, 0x0C, 0x06, 0x0F, 0xCF, 0xFE, 0x1E, 0x03, 0x1F, 0x8F, 0xC1, 0xE0, 0xDF, 0xE7,
-    0xE0, 0x18, 0x30, 0xFB, 0xFE, 0x78, 0xF1, 0xE3, 0x7E, 0x7C, 0x18, 0x37, 0xCF, 0x00, 0x3F, 0x3F, 0xF8, 0x78, 0x0C,
-    0x7E, 0x3F, 0x07, 0x83, 0x7F, 0x9F, 0x83, 0x00, 0xC1, 0xC0, 0xE0, 0x18, 0x30, 0x61, 0xF7, 0xFC, 0xF1, 0xE3, 0xC6,
-    0xFC, 0xF8, 0x30, 0x6F, 0x9E, 0x00, 0x18, 0x3C, 0x3C, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xC3, 0xC3, 0xC3, 0xC3,
-    0x31, 0xE7, 0xB0, 0xC3, 0xEF, 0xFB, 0xCF, 0x3C, 0xF3, 0xCC, 0x61, 0xBF, 0xFF, 0xFD, 0x86, 0x7F, 0x9F, 0xE6, 0x19,
-    0x86, 0x61, 0x98, 0x60, 0x61, 0xF3, 0xE3, 0xE7, 0xEE, 0xD9, 0xB3, 0x66, 0xCD, 0x98, 0x7F, 0xEC, 0xC6, 0x31, 0x8C,
-    0x63, 0x18, 0xC6, 0x00, 0x7F, 0xEC, 0x86, 0x31, 0x8C, 0x63, 0x18, 0xFF, 0x66, 0x66, 0x66, 0x66, 0x66, 0xFF, 0x46,
-    0x66, 0x66, 0x66, 0x9F, 0xDC, 0xC6, 0x31, 0x8C, 0x63, 0x18, 0xC6, 0x00, 0x9F, 0xDC, 0x86, 0x31, 0x8C, 0x63, 0x18,
-    0x66, 0x66, 0x66, 0x66, 0x66, 0x6C, 0xF6, 0x66, 0x46, 0x66, 0x66, 0x66, 0x6C, 0xF6, 0xEF, 0xFF, 0xFF, 0xBF, 0xFF,
-    0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xE3, 0xF3, 0xFF, 0xDE, 0xDE, 0xE7, 0xBD, 0xEF, 0x7B, 0xDE, 0xC6, 0x33, 0x10,
-    0x0C, 0x3C, 0x78, 0x60, 0xC1, 0x83, 0x06, 0x0D, 0x1B, 0x37, 0xE7, 0x80, 0x6F, 0xB4, 0x66, 0x66, 0x66, 0x66, 0x6C,
-    0x80, 0xC3, 0xC7, 0xCE, 0xDC, 0xF8, 0xF8, 0xDC, 0xCC, 0xC6, 0xC3, 0x38, 0x1C, 0x38, 0x30, 0xC3, 0x0C, 0xF7, 0xFB,
-    0xCE, 0x3C, 0xDB, 0x37, 0x0E, 0x71, 0x80, 0x8F, 0x7F, 0xBC, 0xE3, 0xCD, 0xB3, 0x30, 0xE1, 0x86, 0x0C, 0x18, 0x30,
-    0x60, 0xC1, 0x83, 0x07, 0xEF, 0xE0, 0x7A, 0x6D, 0xB6, 0xDB, 0x6C, 0xC1, 0x83, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xFD,
-    0xFD, 0xC1, 0xC7, 0x0C, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0xEF, 0xEC, 0x0D, 0x9B, 0x36, 0x6C, 0x18, 0x30, 0x60,
-    0xC1, 0xFB, 0xF8, 0x3F, 0xFF, 0xCC, 0xCC, 0xCC, 0xC0, 0xC1, 0x83, 0x06, 0x0C, 0xD9, 0xB0, 0x60, 0xFD, 0xFC, 0xCC,
-    0xCC, 0xFF, 0xCC, 0xCC, 0x60, 0x60, 0x78, 0x78, 0xF0, 0xE0, 0x60, 0x60, 0x7E, 0x7F, 0x66, 0x67, 0xFE, 0x66, 0x66,
-    0x0C, 0x1C, 0x18, 0xC3, 0xE3, 0xF3, 0xF3, 0xFB, 0xDF, 0xCF, 0xCF, 0xC7, 0xC3, 0x18, 0x63, 0x8C, 0x7B, 0xFC, 0xF3,
-    0xCF, 0x3C, 0xF3, 0xC3, 0xE3, 0xF3, 0xF3, 0xFB, 0xDF, 0xCF, 0xCF, 0xC7, 0xC3, 0x38, 0x1C, 0x38, 0x30, 0x7B, 0xFC,
-    0xF3, 0xCF, 0x3C, 0xF3, 0x70, 0xE7, 0x18, 0x3C, 0x3C, 0x18, 0xC3, 0xE3, 0xF3, 0xF3, 0xFB, 0xDF, 0xCF, 0xCF, 0xC7,
-    0xC3, 0x79, 0xE3, 0x1E, 0xFF, 0x3C, 0xF3, 0xCF, 0x3C, 0xC0, 0x81, 0x83, 0x05, 0xE7, 0xEC, 0xD9, 0xB3, 0x66, 0xCD,
-    0x98, 0xC3, 0xE3, 0xF3, 0xF3, 0xFB, 0xDF, 0xCF, 0xCF, 0xC7, 0xC3, 0x03, 0x03, 0x03, 0x7B, 0xFC, 0xF3, 0xCF, 0x3C,
-    0xF3, 0x0C, 0x31, 0x84, 0x3E, 0x1F, 0x0F, 0x8F, 0xEE, 0x3E, 0x0F, 0x07, 0x83, 0xC1, 0xE1, 0xDF, 0xC7, 0xC0, 0x3C,
-    0x3C, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x36, 0x1F, 0x07, 0x07, 0xC7, 0xF7, 0x1F, 0x07, 0x83, 0xC1,
-    0xE0, 0xF0, 0xEF, 0xE3, 0xE0, 0x36, 0x3E, 0x1C, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x1B, 0x1F, 0x8D,
-    0x87, 0xC7, 0xF7, 0x1F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0xEF, 0xE3, 0xE0, 0x1E, 0x3E, 0x3C, 0x3C, 0x7E, 0xE7, 0xC3,
-    0xC3, 0xC7, 0x7E, 0x3C, 0x3F, 0xFB, 0xFF, 0xF9, 0xC1, 0x86, 0x0C, 0x3F, 0x61, 0xFB, 0x0C, 0x18, 0x60, 0xC7, 0x03,
-    0xFF, 0x0F, 0xFC, 0x3D, 0xE3, 0xFF, 0xB9, 0xCF, 0x87, 0xFC, 0x3F, 0xE3, 0x85, 0xFF, 0xE7, 0xBE, 0x18, 0x38, 0x30,
-    0xFE, 0xFF, 0xC3, 0xC7, 0xFE, 0xFE, 0xC7, 0xC3, 0xC3, 0xC3, 0x33, 0x98, 0xEF, 0xEF, 0x18, 0xC6, 0x30, 0xFE, 0xFF,
-    0xC3, 0xC7, 0xFE, 0xFE, 0xC7, 0xC3, 0xC3, 0xC3, 0x38, 0x1C, 0x38, 0x30, 0x77, 0xF7, 0x8C, 0x63, 0x18, 0xE3, 0xB9,
-    0x80, 0x3C, 0x3C, 0x18, 0xFE, 0xFF, 0xC3, 0xC7, 0xFE, 0xFE, 0xC7, 0xC3, 0xC3, 0xC3, 0xF7, 0x98, 0xEF, 0xEF, 0x18,
-    0xC6, 0x30, 0x18, 0x70, 0xC3, 0xEF, 0xF8, 0xFC, 0x3E, 0x1E, 0x0E, 0x1F, 0xF7, 0xC0, 0x18, 0x70, 0xC3, 0xEF, 0xF8,
-    0xFF, 0x3F, 0x87, 0xFD, 0xF0, 0x18, 0x78, 0xF3, 0xEF, 0xF8, 0xFC, 0x3E, 0x1E, 0x0E, 0x1F, 0xF7, 0xC0, 0x18, 0x78,
-    0xF3, 0xEF, 0xF8, 0xFF, 0x3F, 0x87, 0xFD, 0xF0, 0x7D, 0xFF, 0x1F, 0x87, 0xC3, 0xC1, 0xC3, 0xFE, 0xF8, 0xC0, 0xC7,
-    0x0C, 0x00, 0x7D, 0xFF, 0x1F, 0xE7, 0xF0, 0xFF, 0xBE, 0x18, 0x18, 0xE1, 0x80, 0x3C, 0x78, 0x63, 0xEF, 0xF8, 0xFC,
-    0x3E, 0x1E, 0x0E, 0x1F, 0xF7, 0xC0, 0x3C, 0x78, 0x63, 0xEF, 0xF8, 0xFF, 0x3F, 0x87, 0xFD, 0xF0, 0xFF, 0xFF, 0xC6,
-    0x03, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x01, 0x83, 0x81, 0x80, 0x63, 0x3D, 0xE6, 0x31, 0x8C, 0x71,
-    0xCC, 0x37, 0x30, 0x3C, 0x3C, 0x18, 0xFF, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x0D, 0xB6, 0xFF,
-    0xF1, 0x86, 0x18, 0x61, 0xC3, 0x80, 0xFF, 0xFF, 0x18, 0x18, 0x7E, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x63, 0x3D, 0xE6,
-    0x73, 0xCC, 0x71, 0xC0, 0x1E, 0x3E, 0x3C, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x3D, 0xF7,
-    0xA3, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80, 0x3C, 0x3C, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C,
-    0x79, 0xE8, 0xF3, 0xCF, 0x3C, 0xF3, 0xFD, 0xE0, 0x36, 0x3E, 0x1C, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7,
-    0x7E, 0x3C, 0x6D, 0xF3, 0xA3, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80, 0x18, 0x3C, 0x3C, 0xDB, 0xC3, 0xC3, 0xC3, 0xC3,
-    0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x31, 0xE7, 0xAF, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80, 0x1E, 0x3E, 0x3C, 0xC3, 0xC3,
-    0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x3D, 0xF7, 0xA3, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80, 0xC3, 0xC3,
-    0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x18, 0x30, 0x3C, 0x1C, 0x8D, 0x9B, 0x36, 0x6C, 0xD9, 0xBF, 0x3E,
-    0x0C, 0x30, 0x78, 0x70, 0x03, 0x00, 0x1E, 0x00, 0x78, 0x20, 0xC3, 0xC3, 0x0F, 0x0C, 0x3C, 0x79, 0xD9, 0xE6, 0x6F,
-    0xF8, 0xF3, 0xC3, 0xCF, 0x0F, 0x3C, 0x18, 0x60, 0x0C, 0x07, 0x81, 0xE2, 0x03, 0xCC, 0xF7, 0xF7, 0xF9, 0xFE, 0x7F,
-    0x8C, 0xC3, 0x30, 0x18, 0x3C, 0x3C, 0xC3, 0xC3, 0xE7, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x3C,
-    0x83, 0xC7, 0x66, 0x6E, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x70, 0x60, 0x3C, 0x3C, 0xC3, 0xC3, 0xE7, 0x7E, 0x3C, 0x18,
-    0x18, 0x18, 0x18, 0x18, 0x0C, 0x1C, 0x18, 0xFF, 0xFF, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0, 0xFE, 0xFF, 0x0C, 0x38,
-    0x67, 0xFF, 0xE3, 0x8E, 0x38, 0xE1, 0xFB, 0xF8, 0x0C, 0x0C, 0xFF, 0xFF, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0, 0xFE,
-    0xFF, 0x18, 0x33, 0xFF, 0xF1, 0xC7, 0x1C, 0x70, 0xFD, 0xFC, 0x3C, 0x3C, 0x18, 0xFF, 0xFF, 0x07, 0x0E, 0x1C, 0x38,
-    0x70, 0xE0, 0xFE, 0xFF, 0x3C, 0x78, 0x67, 0xFF, 0xE3, 0x8E, 0x38, 0xE1, 0xFB, 0xF8, 0x1E, 0x3F, 0x73, 0xFE, 0xFE,
-    0xFE, 0xFE, 0x62, 0x3F, 0x1E,
-};
-
-static const EpdGlyph babyblueGlyphs[] = {
-    {0, 0, 5, 0, 0, 0, 0},          //
-    {2, 10, 3, 1, 10, 3, 0},        // !
-    {4, 5, 5, 1, 11, 3, 3},         // "
-    {9, 11, 10, 0, 11, 13, 6},      // #
-    {8, 14, 9, 0, 12, 14, 19},      // $
-    {11, 11, 13, 1, 11, 16, 33},    // %
-    {9, 11, 11, 1, 11, 13, 49},     // &
-    {2, 4, 3, 1, 11, 1, 62},        // '
-    {4, 15, 5, 1, 11, 8, 63},       // (
-    {4, 15, 5, 1, 11, 8, 71},       // )
-    {6, 6, 6, 0, 11, 5, 79},        // *
-    {8, 8, 9, 0, 9, 8, 84},         // +
-    {2, 5, 3, 1, 3, 2, 92},         // ,
-    {5, 2, 5, 0, 5, 2, 94},         // -
-    {2, 2, 3, 1, 2, 1, 96},         // .
-    {6, 11, 6, 0, 11, 9, 97},       // /
-    {8, 11, 9, 0, 11, 11, 106},     // 0
-    {5, 11, 6, 1, 11, 7, 117},      // 1
-    {8, 11, 9, 0, 11, 11, 124},     // 2
-    {8, 11, 10, 1, 11, 11, 135},    // 3
-    {8, 11, 9, 0, 11, 11, 146},     // 4
-    {7, 11, 9, 1, 11, 10, 157},     // 5
-    {8, 11, 9, 0, 11, 11, 167},     // 6
-    {9, 11, 10, 0, 11, 13, 178},    // 7
-    {8, 11, 9, 0, 11, 11, 191},     // 8
-    {8, 11, 9, 0, 11, 11, 202},     // 9
-    {2, 8, 3, 1, 8, 2, 213},        // :
-    {2, 11, 3, 1, 8, 3, 215},       // ;
-    {7, 8, 9, 1, 9, 7, 218},        // <
-    {8, 5, 9, 0, 8, 5, 225},        // =
-    {7, 8, 7, 0, 9, 7, 230},        // >
-    {7, 11, 9, 1, 11, 10, 237},     // ?
-    {14, 15, 15, 0, 11, 27, 247},   // @
-    {7, 10, 9, 1, 10, 9, 274},      // A
-    {8, 10, 10, 1, 10, 10, 283},    // B
-    {9, 10, 11, 1, 10, 12, 293},    // C
-    {8, 10, 10, 1, 10, 10, 305},    // D
-    {7, 10, 9, 1, 10, 9, 315},      // E
-    {7, 10, 9, 1, 10, 9, 324},      // F
-    {9, 10, 11, 1, 10, 12, 333},    // G
-    {8, 10, 10, 1, 10, 10, 345},    // H
-    {2, 10, 3, 1, 10, 3, 355},      // I
-    {6, 10, 6, 0, 10, 8, 358},      // J
-    {8, 10, 10, 1, 10, 10, 366},    // K
-    {7, 10, 9, 1, 10, 9, 376},      // L
-    {10, 10, 12, 1, 10, 13, 385},   // M
-    {8, 10, 10, 1, 10, 10, 398},    // N
-    {9, 10, 11, 1, 10, 12, 408},    // O
-    {8, 10, 10, 1, 10, 10, 420},    // P
-    {9, 10, 11, 1, 10, 12, 430},    // Q
-    {8, 10, 10, 1, 10, 10, 442},    // R
-    {7, 10, 9, 1, 10, 9, 452},      // S
-    {8, 10, 9, 0, 10, 10, 461},     // T
-    {8, 10, 10, 1, 10, 10, 471},    // U
-    {8, 10, 10, 1, 10, 10, 481},    // V
-    {14, 10, 15, 0, 10, 18, 491},   // W
-    {10, 10, 11, 0, 10, 13, 509},   // X
-    {8, 10, 10, 1, 10, 10, 522},    // Y
-    {8, 10, 9, 0, 10, 10, 532},     // Z
-    {4, 14, 5, 1, 10, 7, 542},      // [
-    {7, 10, 7, 0, 10, 9, 549},      // <backslash>
-    {4, 14, 4, 0, 10, 7, 558},      // ]
-    {8, 7, 9, 0, 11, 7, 565},       // ^
-    {8, 2, 9, 0, -2, 2, 572},       // _
-    {3, 3, 3, 0, 11, 2, 574},       // `
-    {7, 8, 7, 0, 8, 7, 576},        // a
-    {7, 10, 9, 1, 10, 9, 583},      // b
-    {7, 8, 7, 0, 8, 7, 592},        // c
-    {7, 10, 7, 0, 10, 9, 599},      // d
-    {8, 8, 9, 0, 8, 8, 608},        // e
-    {5, 11, 5, 0, 11, 7, 616},      // f
-    {7, 12, 7, 0, 8, 11, 623},      // g
-    {6, 10, 7, 1, 10, 8, 634},      // h
-    {2, 10, 3, 1, 10, 3, 642},      // i
-    {3, 14, 3, 0, 10, 6, 645},      // j
-    {6, 10, 7, 1, 10, 8, 651},      // k
-    {2, 10, 3, 1, 10, 3, 659},      // l
-    {10, 8, 12, 1, 8, 10, 662},     // m
-    {6, 8, 7, 1, 8, 6, 672},        // n
-    {8, 8, 9, 0, 8, 8, 678},        // o
-    {7, 11, 9, 1, 8, 10, 686},      // p
-    {7, 11, 7, 0, 8, 10, 696},      // q
-    {5, 8, 6, 1, 8, 5, 706},        // r
-    {7, 8, 7, 0, 8, 7, 711},        // s
-    {5, 10, 5, 0, 10, 7, 718},      // t
-    {6, 8, 7, 1, 8, 6, 725},        // u
-    {8, 8, 9, 0, 8, 8, 731},        // v
-    {10, 8, 11, 0, 8, 10, 739},     // w
-    {8, 8, 9, 0, 8, 8, 749},        // x
-    {8, 11, 9, 0, 8, 11, 757},      // y
-    {7, 8, 7, 0, 8, 7, 768},        // z
-    {5, 15, 5, 0, 11, 10, 775},     // {
-    {2, 15, 3, 1, 11, 4, 785},      // |
-    {6, 15, 6, 0, 11, 12, 789},     // }
-    {9, 3, 10, 0, 7, 4, 801},       // ~
-    {2, 12, 4, 2, 8, 3, 805},       // ¡
-    {7, 13, 7, 0, 10, 12, 808},     // ¢
-    {8, 10, 9, 0, 10, 10, 820},     // £
-    {8, 8, 9, 0, 9, 8, 830},        // ¤
-    {8, 10, 9, 0, 10, 10, 838},     // ¥
-    {2, 15, 3, 1, 11, 4, 848},      // ¦
-    {8, 15, 9, 0, 11, 15, 852},     // §
-    {5, 3, 5, 0, 11, 2, 867},       // ¨
-    {10, 11, 11, 0, 11, 14, 869},   // ©
-    {5, 6, 5, 0, 11, 4, 883},       // ª
-    {7, 7, 9, 1, 8, 7, 887},        // «
-    {8, 5, 9, 0, 8, 5, 894},        // ¬
-    {10, 11, 11, 0, 11, 14, 899},   // ®
-    {8, 2, 9, 0, 12, 2, 913},       // ¯
-    {4, 5, 5, 1, 11, 3, 915},       // °
-    {8, 9, 9, 0, 9, 9, 918},        // ±
-    {5, 8, 5, 0, 11, 5, 927},       // ²
-    {5, 6, 5, 0, 11, 4, 932},       // ³
-    {3, 3, 4, 1, 11, 2, 936},       // ´
-    {6, 12, 9, 2, 8, 9, 938},       // µ
-    {8, 14, 9, 0, 10, 14, 947},     // ¶
-    {2, 2, 3, 1, 6, 1, 961},        // ·
-    {4, 4, 4, 0, 0, 2, 962},        // ¸
-    {4, 7, 4, 0, 12, 4, 964},       // ¹
-    {6, 6, 6, 0, 11, 5, 968},       // º
-    {7, 7, 9, 1, 8, 7, 973},        // »
-    {12, 12, 13, 0, 12, 18, 980},   // ¼
-    {12, 11, 13, 0, 11, 17, 998},   // ½
-    {12, 11, 13, 0, 11, 17, 1015},  // ¾
-    {7, 12, 9, 1, 8, 11, 1032},     // ¿
-    {7, 13, 9, 1, 13, 12, 1043},    // À
-    {7, 13, 9, 1, 13, 12, 1055},    // Á
-    {7, 13, 9, 1, 13, 12, 1067},    // Â
-    {7, 13, 9, 1, 13, 12, 1079},    // Ã
-    {7, 12, 9, 1, 12, 11, 1091},    // Ä
-    {7, 13, 9, 1, 13, 12, 1102},    // Å
-    {13, 11, 14, 0, 11, 18, 1114},  // Æ
-    {9, 14, 11, 1, 10, 16, 1132},   // Ç
-    {7, 13, 9, 1, 13, 12, 1148},    // È
-    {7, 13, 9, 1, 13, 12, 1160},    // É
-    {7, 13, 9, 1, 13, 12, 1172},    // Ê
-    {7, 12, 9, 1, 12, 11, 1184},    // Ë
-    {3, 13, 3, 0, 13, 5, 1195},     // Ì
-    {3, 13, 4, 1, 13, 5, 1200},     // Í
-    {4, 13, 4, 0, 13, 7, 1205},     // Î
-    {4, 12, 4, 0, 12, 6, 1212},     // Ï
-    {9, 10, 10, 0, 10, 12, 1218},   // Ð
-    {8, 13, 10, 1, 13, 13, 1230},   // Ñ
-    {9, 13, 11, 1, 13, 15, 1243},   // Ò
-    {9, 13, 11, 1, 13, 15, 1258},   // Ó
-    {9, 13, 11, 1, 13, 15, 1273},   // Ô
-    {9, 13, 11, 1, 13, 15, 1288},   // Õ
-    {9, 12, 11, 1, 12, 14, 1303},   // Ö
-    {6, 6, 7, 1, 8, 5, 1317},       // ×
-    {10, 10, 11, 0, 10, 13, 1322},  // Ø
-    {8, 13, 10, 1, 13, 13, 1335},   // Ù
-    {8, 13, 10, 1, 13, 13, 1348},   // Ú
-    {8, 13, 10, 1, 13, 13, 1361},   // Û
-    {8, 12, 10, 1, 12, 12, 1374},   // Ü
-    {8, 13, 10, 1, 13, 13, 1386},   // Ý
-    {8, 10, 10, 1, 10, 10, 1399},   // Þ
-    {7, 11, 9, 1, 11, 10, 1409},    // ß
-    {7, 11, 7, 0, 11, 10, 1419},    // à
-    {7, 11, 7, 0, 11, 10, 1429},    // á
-    {7, 11, 7, 0, 11, 10, 1439},    // â
-    {7, 11, 7, 0, 11, 10, 1449},    // ã
-    {7, 10, 7, 0, 10, 9, 1459},     // ä
-    {7, 12, 7, 0, 12, 11, 1468},    // å
-    {12, 8, 13, 0, 8, 12, 1479},    // æ
-    {7, 12, 7, 0, 8, 11, 1491},     // ç
-    {8, 11, 9, 0, 11, 11, 1502},    // è
-    {8, 11, 9, 0, 11, 11, 1513},    // é
-    {8, 11, 9, 0, 11, 11, 1524},    // ê
-    {8, 10, 9, 0, 10, 10, 1535},    // ë
-    {3, 11, 3, 0, 11, 5, 1545},     // ì
-    {3, 11, 4, 1, 11, 5, 1550},     // í
-    {4, 11, 4, 0, 11, 6, 1555},     // î
-    {4, 10, 4, 0, 10, 5, 1561},     // ï
-    {8, 11, 9, 0, 11, 11, 1566},    // ð
-    {6, 11, 7, 1, 11, 9, 1577},     // ñ
-    {8, 11, 9, 0, 11, 11, 1586},    // ò
-    {8, 11, 9, 0, 11, 11, 1597},    // ó
-    {8, 11, 9, 0, 11, 11, 1608},    // ô
-    {8, 11, 9, 0, 11, 11, 1619},    // õ
-    {8, 10, 9, 0, 10, 10, 1630},    // ö
-    {8, 6, 9, 0, 8, 6, 1640},       // ÷
-    {8, 8, 9, 0, 8, 8, 1646},       // ø
-    {6, 11, 7, 1, 11, 9, 1654},     // ù
-    {6, 11, 7, 1, 11, 9, 1663},     // ú
-    {6, 11, 7, 1, 11, 9, 1672},     // û
-    {6, 10, 7, 1, 10, 8, 1681},     // ü
-    {8, 14, 9, 0, 11, 14, 1689},    // ý
-    {7, 13, 9, 1, 10, 12, 1703},    // þ
-    {8, 13, 9, 0, 10, 13, 1715},    // ÿ
-    {7, 12, 9, 1, 12, 11, 1728},    // Ā
-    {7, 10, 7, 0, 10, 9, 1739},     // ā
-    {7, 13, 9, 1, 13, 12, 1748},    // Ă
-    {7, 11, 7, 0, 11, 10, 1760},    // ă
-    {8, 14, 10, 1, 10, 14, 1770},   // Ą
-    {8, 12, 9, 0, 8, 12, 1784},     // ą
-    {9, 13, 11, 1, 13, 15, 1796},   // Ć
-    {7, 11, 7, 0, 11, 10, 1811},    // ć
-    {9, 13, 11, 1, 13, 15, 1821},   // Ĉ
-    {7, 11, 7, 0, 11, 10, 1836},    // ĉ
-    {9, 12, 11, 1, 12, 14, 1846},   // Ċ
-    {7, 10, 7, 0, 10, 9, 1860},     // ċ
-    {9, 13, 11, 1, 13, 15, 1869},   // Č
-    {7, 11, 7, 0, 11, 10, 1884},    // č
-    {8, 13, 10, 1, 13, 13, 1894},   // Ď
-    {9, 11, 10, 0, 11, 13, 1907},   // ď
-    {9, 10, 10, 0, 10, 12, 1920},   // Đ
-    {8, 11, 9, 0, 11, 11, 1932},    // đ
-    {7, 12, 9, 1, 12, 11, 1943},    // Ē
-    {8, 10, 9, 0, 10, 10, 1954},    // ē
-    {7, 13, 9, 1, 13, 12, 1964},    // Ĕ
-    {8, 11, 9, 0, 11, 11, 1976},    // ĕ
-    {7, 12, 9, 1, 12, 11, 1987},    // Ė
-    {8, 10, 9, 0, 10, 10, 1998},    // ė
-    {8, 14, 10, 1, 10, 14, 2008},   // Ę
-    {8, 12, 9, 0, 8, 12, 2022},     // ę
-    {7, 13, 9, 1, 13, 12, 2034},    // Ě
-    {8, 11, 9, 0, 11, 11, 2046},    // ě
-    {9, 13, 11, 1, 13, 15, 2057},   // Ĝ
-    {7, 15, 7, 0, 11, 14, 2072},    // ĝ
-    {9, 13, 11, 1, 13, 15, 2086},   // Ğ
-    {7, 15, 7, 0, 11, 14, 2101},    // ğ
-    {9, 12, 11, 1, 12, 14, 2115},   // Ġ
-    {7, 14, 7, 0, 10, 13, 2129},    // ġ
-    {9, 14, 11, 1, 10, 16, 2142},   // Ģ
-    {7, 15, 7, 0, 11, 14, 2158},    // ģ
-    {8, 13, 10, 1, 13, 13, 2172},   // Ĥ
-    {6, 13, 7, 1, 13, 10, 2185},    // ĥ
-    {10, 10, 11, 0, 10, 13, 2195},  // Ħ
-    {7, 11, 7, 0, 11, 10, 2208},    // ħ
-    {5, 13, 5, 0, 13, 9, 2218},     // Ĩ
-    {5, 11, 5, 0, 11, 7, 2227},     // ĩ
-    {4, 12, 4, 0, 12, 6, 2234},     // Ī
-    {4, 10, 4, 0, 10, 5, 2240},     // ī
-    {5, 13, 5, 0, 13, 9, 2245},     // Ĭ
-    {5, 11, 5, 0, 11, 7, 2254},     // ĭ
-    {4, 14, 4, 0, 10, 7, 2261},     // Į
-    {4, 14, 4, 0, 10, 7, 2268},     // į
-    {2, 12, 3, 1, 12, 3, 2275},     // İ
-    {2, 8, 3, 1, 8, 2, 2278},       // ı
-    {8, 10, 10, 1, 10, 10, 2280},   // IJ
-    {5, 14, 6, 1, 10, 9, 2290},     // ij
-    {7, 13, 7, 0, 13, 12, 2299},    // Ĵ
-    {4, 15, 4, 0, 11, 8, 2311},     // ĵ
-    {8, 14, 10, 1, 10, 14, 2319},   // Ķ
-    {6, 14, 7, 1, 10, 11, 2333},    // ķ
-    {6, 8, 7, 1, 8, 6, 2344},       // ĸ
-    {7, 13, 9, 1, 13, 12, 2350},    // Ĺ
-    {3, 13, 4, 1, 13, 5, 2362},     // ĺ
-    {7, 14, 9, 1, 10, 13, 2367},    // Ļ
-    {4, 14, 4, 0, 10, 7, 2380},     // ļ
-    {7, 11, 9, 1, 11, 10, 2387},    // Ľ
-    {4, 11, 5, 1, 11, 6, 2397},     // ľ
-    {7, 10, 9, 1, 10, 9, 2403},     // Ŀ
-    {4, 10, 5, 1, 10, 5, 2412},     // ŀ
-    {8, 10, 9, 0, 10, 10, 2417},    // Ł
-    {4, 10, 4, 0, 10, 5, 2427},     // ł
-    {8, 13, 10, 1, 13, 13, 2432},   // Ń
-    {6, 12, 7, 1, 12, 9, 2445},     // ń
-    {8, 14, 10, 1, 10, 14, 2454},   // Ņ
-    {6, 12, 7, 1, 8, 9, 2468},      // ņ
-    {8, 13, 10, 1, 13, 13, 2477},   // Ň
-    {6, 11, 7, 1, 11, 9, 2490},     // ň
-    {7, 11, 7, 0, 11, 10, 2499},    // ʼn
-    {8, 13, 10, 1, 10, 13, 2509},   // Ŋ
-    {6, 12, 7, 1, 8, 9, 2522},      // ŋ
-    {9, 12, 11, 1, 12, 14, 2531},   // Ō
-    {8, 10, 9, 0, 10, 10, 2545},    // ō
-    {9, 13, 11, 1, 13, 15, 2555},   // Ŏ
-    {8, 11, 9, 0, 11, 11, 2570},    // ŏ
-    {9, 13, 11, 1, 13, 15, 2581},   // Ő
-    {8, 11, 9, 0, 11, 11, 2596},    // ő
-    {13, 11, 15, 1, 11, 18, 2607},  // Œ
-    {13, 8, 14, 0, 8, 13, 2625},    // œ
-    {8, 13, 10, 1, 13, 13, 2638},   // Ŕ
-    {5, 11, 6, 1, 11, 7, 2651},     // ŕ
-    {8, 14, 10, 1, 10, 14, 2658},   // Ŗ
-    {5, 12, 6, 1, 8, 8, 2672},      // ŗ
-    {8, 13, 10, 1, 13, 13, 2680},   // Ř
-    {5, 11, 6, 1, 11, 7, 2693},     // ř
-    {7, 13, 9, 1, 13, 12, 2700},    // Ś
-    {7, 11, 7, 0, 11, 10, 2712},    // ś
-    {7, 13, 9, 1, 13, 12, 2722},    // Ŝ
-    {7, 11, 7, 0, 11, 10, 2734},    // ŝ
-    {7, 14, 9, 1, 10, 13, 2744},    // Ş
-    {7, 12, 7, 0, 8, 11, 2757},     // ş
-    {7, 13, 9, 1, 13, 12, 2768},    // Š
-    {7, 11, 7, 0, 11, 10, 2780},    // š
-    {9, 14, 10, 0, 10, 16, 2790},   // Ţ
-    {5, 14, 5, 0, 10, 9, 2806},     // ţ
-    {8, 13, 9, 0, 13, 13, 2815},    // Ť
-    {6, 11, 6, 0, 11, 9, 2828},     // ť
-    {8, 10, 9, 0, 10, 10, 2837},    // Ŧ
-    {5, 10, 5, 0, 10, 7, 2847},     // ŧ
-    {8, 13, 10, 1, 13, 13, 2854},   // Ũ
-    {6, 11, 7, 1, 11, 9, 2867},     // ũ
-    {8, 12, 10, 1, 12, 12, 2876},   // Ū
-    {6, 10, 7, 1, 10, 8, 2888},     // ū
-    {8, 13, 10, 1, 13, 13, 2896},   // Ŭ
-    {6, 11, 7, 1, 11, 9, 2909},     // ŭ
-    {8, 13, 10, 1, 13, 13, 2918},   // Ů
-    {6, 11, 7, 1, 11, 9, 2931},     // ů
-    {8, 13, 10, 1, 13, 13, 2940},   // Ű
-    {6, 11, 7, 1, 11, 9, 2953},     // ű
-    {8, 14, 10, 1, 10, 14, 2962},   // Ų
-    {7, 12, 9, 1, 8, 11, 2976},     // ų
-    {14, 13, 15, 0, 13, 23, 2987},  // Ŵ
-    {10, 11, 11, 0, 11, 14, 3010},  // ŵ
-    {8, 13, 10, 1, 13, 13, 3024},   // Ŷ
-    {8, 14, 9, 0, 11, 14, 3037},    // ŷ
-    {8, 12, 10, 1, 12, 12, 3051},   // Ÿ
-    {8, 13, 9, 0, 13, 13, 3063},    // Ź
-    {7, 11, 7, 0, 11, 10, 3076},    // ź
-    {8, 12, 9, 0, 12, 12, 3086},    // Ż
-    {7, 10, 7, 0, 10, 9, 3098},     // ż
-    {8, 13, 9, 0, 13, 13, 3107},    // Ž
-    {7, 11, 7, 0, 11, 10, 3120},    // ž
-    {8, 10, 9, 0, 10, 10, 3130},    // €
-};
-
-static const EpdUnicodeInterval babyblueIntervals[] = {
-    {0x20, 0x7E, 0x0}, {0xA1, 0xAC, 0x5F}, {0xAE, 0xFF, 0x6B}, {0x100, 0x17E, 0xBD}, {0x20AC, 0x20AC, 0x13C},
-};
-
-static const EpdFontData babyblue = {
-    babyblueBitmaps, babyblueGlyphs, babyblueIntervals, 5, 17, 13, -4,
-};

lib/EpdFont/scripts/fontconvert.py

@@ -13,12 +13,14 @@ parser = argparse.ArgumentParser(description="Generate a header file from a font
 parser.add_argument("name", action="store", help="name of the font.")
 parser.add_argument("size", type=int, help="font size to use.")
 parser.add_argument("fontstack", action="store", nargs='+', help="list of font files, ordered by descending priority.")
+parser.add_argument("--2bit", dest="is2Bit", action="store_true", help="generate 2-bit greyscale bitmap instead of 1-bit black and white.")
 parser.add_argument("--additional-intervals", dest="additional_intervals", action="append", help="Additional code point intervals to export as min,max. This argument can be repeated.")
 args = parser.parse_args()
 
 GlyphProps = namedtuple("GlyphProps", ["width", "height", "advance_x", "left", "top", "data_length", "data_offset", "code_point"])
 
 font_stack = [freetype.Face(f) for f in args.fontstack]
+is2Bit = args.is2Bit
 size = args.size
 font_name = args.name
 
@@ -52,7 +54,7 @@ intervals = [
     # (0x0370, 0x03FF),
     ### Cyrillic ###
     # Russian, Ukrainian, Bulgarian, etc.
-    # (0x0400, 0x04FF),
+    (0x0400, 0x04FF),
     ### Math Symbols (common subset) ###
     # General math operators
     (0x2200, 0x22FF),
@@ -173,26 +175,73 @@ for i_start, i_end in intervals:
                 pixels4g.append(px)
                 px = 0
 
-        # Downsample to 1-bit bitmap - treat any non-zero as black
+        if is2Bit:
-        pixelsbw = []
+            # 0-3 white, 4-7 light grey, 8-11 dark grey, 12-15 black
-        px = 0
+            # Downsample to 2-bit bitmap
-        pitch = (bitmap.width // 2) + (bitmap.width % 2)
+            pixels2b = []
-        for y in range(bitmap.rows):
+            px = 0
-            for x in range(bitmap.width):
+            pitch = (bitmap.width // 2) + (bitmap.width % 2)
-                px = px << 1
+            for y in range(bitmap.rows):
-                bm = pixels4g[y * pitch + (x // 2)]
+                for x in range(bitmap.width):
-                px += 1 if ((x & 1) == 0 and bm & 0xF > 0) or ((x & 1) == 1 and bm & 0xF0 > 0) else 0
+                    px = px << 2
+                    bm = pixels4g[y * pitch + (x // 2)]
+                    bm = (bm >> ((x % 2) * 4)) & 0xF
 
-                if (y * bitmap.width + x) % 8 == 7:
+                    if bm >= 12:
-                    pixelsbw.append(px)
+                        px += 3
-                    px = 0
+                    elif bm >= 8:
-        if (bitmap.width * bitmap.rows) % 8 != 0:
+                        px += 2
-            px = px << (8 - (bitmap.width * bitmap.rows) % 8)
+                    elif bm >= 4:
-            pixelsbw.append(px)
+                        px += 1
 
+                    if (y * bitmap.width + x) % 4 == 3:
+                        pixels2b.append(px)
+                        px = 0
+            if (bitmap.width * bitmap.rows) % 4 != 0:
+                px = px << (4 - (bitmap.width * bitmap.rows) % 4) * 2
+                pixels2b.append(px)
+
+            # for y in range(bitmap.rows):
+            #     line = ''
+            #     for x in range(bitmap.width):
+            #         pixelPosition = y * bitmap.width + x
+            #         byte = pixels2b[pixelPosition // 4]
+            #         bit_index = (3 - (pixelPosition % 4)) * 2
+            #         line += '#' if ((byte >> bit_index) & 3) > 0 else '.'
+            #     print(line)
+            # print('')
+        else:
+            # Downsample to 1-bit bitmap - treat any 2+ as black
+            pixelsbw = []
+            px = 0
+            pitch = (bitmap.width // 2) + (bitmap.width % 2)
+            for y in range(bitmap.rows):
+                for x in range(bitmap.width):
+                    px = px << 1
+                    bm = pixels4g[y * pitch + (x // 2)]
+                    px += 1 if ((x & 1) == 0 and bm & 0xE > 0) or ((x & 1) == 1 and bm & 0xE0 > 0) else 0
+
+                    if (y * bitmap.width + x) % 8 == 7:
+                        pixelsbw.append(px)
+                        px = 0
+            if (bitmap.width * bitmap.rows) % 8 != 0:
+                px = px << (8 - (bitmap.width * bitmap.rows) % 8)
+                pixelsbw.append(px)
+
+            # for y in range(bitmap.rows):
+            #     line = ''
+            #     for x in range(bitmap.width):
+            #         pixelPosition = y * bitmap.width + x
+            #         byte = pixelsbw[pixelPosition // 8]
+            #         bit_index = 7 - (pixelPosition % 8)
+            #         line += '#' if (byte >> bit_index) & 1 else '.'
+            #     print(line)
+            # print('')
+
+        pixels = pixels2b if is2Bit else pixelsbw
 
         # Build output data
-        packed = bytes(pixelsbw)
+        packed = bytes(pixels)
         glyph = GlyphProps(
             width = bitmap.width,
             height = bitmap.rows,
@@ -216,7 +265,7 @@ for index, glyph in enumerate(all_glyphs):
     glyph_data.extend([b for b in packed])
     glyph_props.append(props)
 
-print(f"/**\n * generated by fontconvert.py\n * name: {font_name}\n * size: {size}\n */")
+print(f"/**\n * generated by fontconvert.py\n * name: {font_name}\n * size: {size}\n * mode: {'2-bit' if is2Bit else '1-bit'}\n */")
 print("#pragma once")
 print("#include \"EpdFontData.h\"\n")
 print(f"static const uint8_t {font_name}Bitmaps[{len(glyph_data)}] = {{")
@@ -244,4 +293,5 @@ print(f"    {len(intervals)},")
 print(f"    {norm_ceil(face.size.height)},")
 print(f"    {norm_ceil(face.size.ascender)},")
 print(f"    {norm_floor(face.size.descender)},")
+print(f"    {'true' if is2Bit else 'false'},")
 print("};")

lib/EpdFontRenderer/EpdFontRenderer.hpp

@@ -1,84 +0,0 @@
-#pragma once
-#include <EpdFontFamily.h>
-#include <HardwareSerial.h>
-#include <Utf8.h>
-
-inline int min(const int a, const int b) { return a < b ? a : b; }
-inline int max(const int a, const int b) { return a > b ? a : b; }
-
-template <typename Renderable>
-class EpdFontRenderer {
-  Renderable& renderer;
-  void renderChar(uint32_t cp, int* x, const int* y, uint16_t color, EpdFontStyle style = REGULAR);
-
- public:
-  const EpdFontFamily* fontFamily;
-  explicit EpdFontRenderer(const EpdFontFamily* fontFamily, Renderable& renderer)
-      : fontFamily(fontFamily), renderer(renderer) {}
-  ~EpdFontRenderer() = default;
-  void renderString(const char* string, int* x, int* y, uint16_t color, EpdFontStyle style = REGULAR);
-};
-
-template <typename Renderable>
-void EpdFontRenderer<Renderable>::renderString(const char* string, int* x, int* y, const uint16_t color,
-                                               const EpdFontStyle style) {
-  // cannot draw a NULL / empty string
-  if (string == nullptr || *string == '\0') {
-    return;
-  }
-
-  // no printable characters
-  if (!fontFamily->hasPrintableChars(string, style)) {
-    return;
-  }
-
-  uint32_t cp;
-  while ((cp = utf8NextCodepoint(reinterpret_cast<const uint8_t**>(&string)))) {
-    renderChar(cp, x, y, color, style);
-  }
-
-  *y += fontFamily->getData(style)->advanceY;
-}
-
-template <typename Renderable>
-void EpdFontRenderer<Renderable>::renderChar(const uint32_t cp, int* x, const int* y, uint16_t color,
-                                             const EpdFontStyle style) {
-  const EpdGlyph* glyph = fontFamily->getGlyph(cp, style);
-  if (!glyph) {
-    // TODO: Replace with fallback glyph property?
-    glyph = fontFamily->getGlyph('?', style);
-  }
-
-  // no glyph?
-  if (!glyph) {
-    Serial.printf("No glyph for codepoint %d\n", cp);
-    return;
-  }
-
-  const uint32_t offset = glyph->dataOffset;
-  const uint8_t width = glyph->width;
-  const uint8_t height = glyph->height;
-  const int left = glyph->left;
-
-  const uint8_t* bitmap = nullptr;
-  bitmap = &fontFamily->getData(style)->bitmap[offset];
-
-  if (bitmap != nullptr) {
-    for (int glyphY = 0; glyphY < height; glyphY++) {
-      int screenY = *y - glyph->top + glyphY;
-      for (int glyphX = 0; glyphX < width; glyphX++) {
-        const int pixelPosition = glyphY * width + glyphX;
-        int screenX = *x + left + glyphX;
-
-        const uint8_t byte = bitmap[pixelPosition / 8];
-        const uint8_t bit_index = 7 - (pixelPosition % 8);
-
-        if ((byte >> bit_index) & 1) {
-          renderer.drawPixel(screenX, screenY, color);
-        }
-      }
-    }
-  }
-
-  *x += glyph->advanceX;
-}

lib/EpdRenderer/EpdRenderer.cpp

@@ -1,168 +0,0 @@
-#include "EpdRenderer.h"
-
-#include "builtinFonts/babyblue.h"
-#include "builtinFonts/bookerly.h"
-#include "builtinFonts/bookerly_bold.h"
-#include "builtinFonts/bookerly_bold_italic.h"
-#include "builtinFonts/bookerly_italic.h"
-#include "builtinFonts/ubuntu_10.h"
-#include "builtinFonts/ubuntu_bold_10.h"
-
-EpdFont bookerlyFont(&bookerly);
-EpdFont bookerlyBoldFont(&bookerly_bold);
-EpdFont bookerlyItalicFont(&bookerly_italic);
-EpdFont bookerlyBoldItalicFont(&bookerly_bold_italic);
-EpdFontFamily bookerlyFontFamily(&bookerlyFont, &bookerlyBoldFont, &bookerlyItalicFont, &bookerlyBoldItalicFont);
-
-EpdFont smallFont(&babyblue);
-EpdFontFamily smallFontFamily(&smallFont);
-
-EpdFont ubuntu10Font(&ubuntu_10);
-EpdFont ununtuBold10Font(&ubuntu_bold_10);
-EpdFontFamily ubuntuFontFamily(&ubuntu10Font, &ununtuBold10Font);
-
-EpdRenderer::EpdRenderer(XteinkDisplay& display)
-    : display(display), marginTop(11), marginBottom(30), marginLeft(10), marginRight(10), lineCompression(0.95f) {
-  this->regularFontRenderer = new EpdFontRenderer<XteinkDisplay>(&bookerlyFontFamily, display);
-  this->smallFontRenderer = new EpdFontRenderer<XteinkDisplay>(&smallFontFamily, display);
-  this->uiFontRenderer = new EpdFontRenderer<XteinkDisplay>(&ubuntuFontFamily, display);
-}
-
-EpdRenderer::~EpdRenderer() {
-  delete regularFontRenderer;
-  delete smallFontRenderer;
-  delete uiFontRenderer;
-}
-
-int EpdRenderer::getTextWidth(const char* text, const EpdFontStyle style) const {
-  int w = 0, h = 0;
-
-  regularFontRenderer->fontFamily->getTextDimensions(text, &w, &h, style);
-
-  return w;
-}
-
-int EpdRenderer::getUiTextWidth(const char* text, const EpdFontStyle style) const {
-  int w = 0, h = 0;
-
-  uiFontRenderer->fontFamily->getTextDimensions(text, &w, &h, style);
-
-  return w;
-}
-
-int EpdRenderer::getSmallTextWidth(const char* text, const EpdFontStyle style) const {
-  int w = 0, h = 0;
-
-  smallFontRenderer->fontFamily->getTextDimensions(text, &w, &h, style);
-
-  return w;
-}
-
-void EpdRenderer::drawText(const int x, const int y, const char* text, const uint16_t color,
-                           const EpdFontStyle style) const {
-  int ypos = y + getLineHeight() + marginTop;
-  int xpos = x + marginLeft;
-  regularFontRenderer->renderString(text, &xpos, &ypos, color > 0 ? GxEPD_BLACK : GxEPD_WHITE, style);
-}
-
-void EpdRenderer::drawUiText(const int x, const int y, const char* text, const uint16_t color,
-                             const EpdFontStyle style) const {
-  int ypos = y + uiFontRenderer->fontFamily->getData(style)->advanceY + marginTop;
-  int xpos = x + marginLeft;
-  uiFontRenderer->renderString(text, &xpos, &ypos, color > 0 ? GxEPD_BLACK : GxEPD_WHITE, style);
-}
-
-void EpdRenderer::drawSmallText(const int x, const int y, const char* text, const uint16_t color,
-                                const EpdFontStyle style) const {
-  int ypos = y + smallFontRenderer->fontFamily->getData(style)->advanceY + marginTop;
-  int xpos = x + marginLeft;
-  smallFontRenderer->renderString(text, &xpos, &ypos, color > 0 ? GxEPD_BLACK : GxEPD_WHITE, style);
-}
-
-void EpdRenderer::drawTextBox(const int x, const int y, const std::string& text, const int width, const int height,
-                              const EpdFontStyle style) const {
-  const size_t length = text.length();
-  // fit the text into the box
-  int start = 0;
-  int end = 1;
-  int ypos = 0;
-  while (true) {
-    if (end >= length) {
-      drawText(x, y + ypos, text.substr(start, length - start).c_str(), 1, style);
-      break;
-    }
-
-    if (ypos + getLineHeight() >= height) {
-      break;
-    }
-
-    if (text[end - 1] == '\n') {
-      drawText(x, y + ypos, text.substr(start, end - start).c_str(), 1, style);
-      ypos += getLineHeight();
-      start = end;
-      end = start + 1;
-      continue;
-    }
-
-    if (getTextWidth(text.substr(start, end - start).c_str(), style) > width) {
-      drawText(x, y + ypos, text.substr(start, end - start - 1).c_str(), 1, style);
-      ypos += getLineHeight();
-      start = end - 1;
-      continue;
-    }
-
-    end++;
-  }
-}
-
-void EpdRenderer::drawLine(int x1, int y1, int x2, int y2, uint16_t color) const {
-  display.drawLine(x1 + marginLeft, y1 + marginTop, x2 + marginLeft, y2 + marginTop,
-                   color > 0 ? GxEPD_BLACK : GxEPD_WHITE);
-}
-
-void EpdRenderer::drawRect(const int x, const int y, const int width, const int height, const uint16_t color) const {
-  display.drawRect(x + marginLeft, y + marginTop, width, height, color > 0 ? GxEPD_BLACK : GxEPD_WHITE);
-}
-
-void EpdRenderer::fillRect(const int x, const int y, const int width, const int height, const uint16_t color) const {
-  display.fillRect(x + marginLeft, y + marginTop, width, height, color > 0 ? GxEPD_BLACK : GxEPD_WHITE);
-}
-
-void EpdRenderer::drawCircle(const int x, const int y, const int radius, const uint16_t color) const {
-  display.drawCircle(x + marginLeft, y + marginTop, radius, color > 0 ? GxEPD_BLACK : GxEPD_WHITE);
-}
-
-void EpdRenderer::fillCircle(const int x, const int y, const int radius, const uint16_t color) const {
-  display.fillCircle(x + marginLeft, y + marginTop, radius, color > 0 ? GxEPD_BLACK : GxEPD_WHITE);
-}
-
-void EpdRenderer::drawImage(const uint8_t bitmap[], const int x, const int y, const int width, const int height,
-                            const bool invert, const bool mirrorY) const {
-  drawImageNoMargin(bitmap, x + marginLeft, y + marginTop, width, height, invert, mirrorY);
-}
-
-void EpdRenderer::drawImageNoMargin(const uint8_t bitmap[], const int x, const int y, const int width, const int height,
-                                    const bool invert, const bool mirrorY) const {
-  display.drawImage(bitmap, x, y, width, height, invert, mirrorY);
-}
-
-void EpdRenderer::clearScreen(const bool black) const {
-  Serial.println("Clearing screen");
-  display.fillScreen(black ? GxEPD_BLACK : GxEPD_WHITE);
-}
-
-void EpdRenderer::flushDisplay(const bool partialUpdate) const { display.display(partialUpdate); }
-
-void EpdRenderer::flushArea(const int x, const int y, const int width, const int height) const {
-  display.displayWindow(x + marginLeft, y + marginTop, width, height);
-}
-
-int EpdRenderer::getPageWidth() const { return display.width() - marginLeft - marginRight; }
-
-int EpdRenderer::getPageHeight() const { return display.height() - marginTop - marginBottom; }
-
-int EpdRenderer::getSpaceWidth() const { return regularFontRenderer->fontFamily->getGlyph(' ', REGULAR)->advanceX; }
-
-int EpdRenderer::getLineHeight() const {
-  return regularFontRenderer->fontFamily->getData(REGULAR)->advanceY * lineCompression;
-}

lib/EpdRenderer/EpdRenderer.h

@@ -1,52 +0,0 @@
-#pragma once
-
-#include <GxEPD2_BW.h>
-
-#include <EpdFontRenderer.hpp>
-
-#define XteinkDisplay GxEPD2_BW<GxEPD2_426_GDEQ0426T82, GxEPD2_426_GDEQ0426T82::HEIGHT>
-
-class EpdRenderer {
-  XteinkDisplay& display;
-  EpdFontRenderer<XteinkDisplay>* regularFontRenderer;
-  EpdFontRenderer<XteinkDisplay>* smallFontRenderer;
-  EpdFontRenderer<XteinkDisplay>* uiFontRenderer;
-  int marginTop;
-  int marginBottom;
-  int marginLeft;
-  int marginRight;
-  float lineCompression;
-
- public:
-  explicit EpdRenderer(XteinkDisplay& display);
-  ~EpdRenderer();
-  int getTextWidth(const char* text, EpdFontStyle style = REGULAR) const;
-  int getUiTextWidth(const char* text, EpdFontStyle style = REGULAR) const;
-  int getSmallTextWidth(const char* text, EpdFontStyle style = REGULAR) const;
-  void drawText(int x, int y, const char* text, uint16_t color = 1, EpdFontStyle style = REGULAR) const;
-  void drawUiText(int x, int y, const char* text, uint16_t color = 1, EpdFontStyle style = REGULAR) const;
-  void drawSmallText(int x, int y, const char* text, uint16_t color = 1, EpdFontStyle style = REGULAR) const;
-  void drawTextBox(int x, int y, const std::string& text, int width, int height, EpdFontStyle style = REGULAR) const;
-  void drawLine(int x1, int y1, int x2, int y2, uint16_t color = 1) const;
-  void drawRect(int x, int y, int width, int height, uint16_t color = 1) const;
-  void fillRect(int x, int y, int width, int height, uint16_t color = 1) const;
-  void drawCircle(int x, int y, int radius, uint16_t color = 1) const;
-  void fillCircle(int x, int y, int radius, uint16_t color = 1) const;
-  void drawImage(const uint8_t bitmap[], int x, int y, int width, int height, bool invert = false,
-                 bool mirrorY = false) const;
-  void drawImageNoMargin(const uint8_t bitmap[], int x, int y, int width, int height, bool invert = false,
-                         bool mirrorY = false) const;
-  void clearScreen(bool black = false) const;
-  void flushDisplay(bool partialUpdate = true) const;
-  void flushArea(int x, int y, int width, int height) const;
-
-  int getPageWidth() const;
-  int getPageHeight() const;
-  int getSpaceWidth() const;
-  int getLineHeight() const;
-  // set margins
-  void setMarginTop(const int newMarginTop) { this->marginTop = newMarginTop; }
-  void setMarginBottom(const int newMarginBottom) { this->marginBottom = newMarginBottom; }
-  void setMarginLeft(const int newMarginLeft) { this->marginLeft = newMarginLeft; }
-  void setMarginRight(const int newMarginRight) { this->marginRight = newMarginRight; }
-};

lib/Epub/Epub.cpp

@@ -1,254 +1,203 @@
 #include "Epub.h"
 
 #include <HardwareSerial.h>
+#include <JpegToBmpConverter.h>
 #include <SD.h>
 #include <ZipFile.h>
 
 #include <map>
 
-bool Epub::findContentOpfFile(const ZipFile& zip, std::string& contentOpfFile) {
+#include "Epub/FsHelpers.h"
-  // open up the meta data to find where the content.opf file lives
+#include "Epub/parsers/ContainerParser.h"
-  size_t s;
+#include "Epub/parsers/ContentOpfParser.h"
-  const auto metaInfo = reinterpret_cast<char*>(zip.readFileToMemory("META-INF/container.xml", &s, true));
+#include "Epub/parsers/TocNcxParser.h"
-  if (!metaInfo) {
+
-    Serial.println("Could not find META-INF/container.xml");
+bool Epub::findContentOpfFile(std::string* contentOpfFile) const {
+  const auto containerPath = "META-INF/container.xml";
+  size_t containerSize;
+
+  // Get file size without loading it all into heap
+  if (!getItemSize(containerPath, &containerSize)) {
+    Serial.printf("[%lu] [EBP] Could not find or size META-INF/container.xml\n", millis());
     return false;
   }
 
-  // parse the meta data
+  ContainerParser containerParser(containerSize);
-  tinyxml2::XMLDocument metaDataDoc;
-  const auto result = metaDataDoc.Parse(metaInfo);
-  free(metaInfo);
 
-  if (result != tinyxml2::XML_SUCCESS) {
+  if (!containerParser.setup()) {
-    Serial.printf("Could not parse META-INF/container.xml. Error: %d\n", result);
     return false;
   }
 
-  const auto container = metaDataDoc.FirstChildElement("container");
+  // Stream read (reusing your existing stream logic)
-  if (!container) {
+  if (!readItemContentsToStream(containerPath, containerParser, 512)) {
-    Serial.println("Could not find container element in META-INF/container.xml");
+    Serial.printf("[%lu] [EBP] Could not read META-INF/container.xml\n", millis());
     return false;
   }
 
-  const auto rootfiles = container->FirstChildElement("rootfiles");
+  // Extract the result
-  if (!rootfiles) {
+  if (containerParser.fullPath.empty()) {
-    Serial.println("Could not find rootfiles element in META-INF/container.xml");
+    Serial.printf("[%lu] [EBP] Could not find valid rootfile in container.xml\n", millis());
     return false;
   }
 
-  // find the root file that has the media-type="application/oebps-package+xml"
+  *contentOpfFile = std::move(containerParser.fullPath);
-  auto rootfile = rootfiles->FirstChildElement("rootfile");
-  while (rootfile) {
-    const char* mediaType = rootfile->Attribute("media-type");
-    if (mediaType && strcmp(mediaType, "application/oebps-package+xml") == 0) {
-      const char* full_path = rootfile->Attribute("full-path");
-      if (full_path) {
-        contentOpfFile = full_path;
-        return true;
-      }
-    }
-    rootfile = rootfile->NextSiblingElement("rootfile");
-  }
-
-  Serial.println("Could not get path to content.opf file");
-  return false;
-}
-
-bool Epub::parseContentOpf(ZipFile& zip, std::string& content_opf_file) {
-  // read in the content.opf file and parse it
-  auto contents = reinterpret_cast<char*>(zip.readFileToMemory(content_opf_file.c_str(), nullptr, true));
-
-  // parse the contents
-  tinyxml2::XMLDocument doc;
-  auto result = doc.Parse(contents);
-  free(contents);
-
-  if (result != tinyxml2::XML_SUCCESS) {
-    Serial.printf("Error parsing content.opf - %s\n", tinyxml2::XMLDocument::ErrorIDToName(result));
-    return false;
-  }
-
-  auto package = doc.FirstChildElement("package");
-  if (!package) package = doc.FirstChildElement("opf:package");
-
-  if (!package) {
-    Serial.println("Could not find package element in content.opf");
-    return false;
-  }
-
-  // get the metadata - title and cover image
-  auto metadata = package->FirstChildElement("metadata");
-  if (!metadata) metadata = package->FirstChildElement("opf:metadata");
-  if (!metadata) {
-    Serial.println("Missing metadata");
-    return false;
-  }
-
-  auto titleEl = metadata->FirstChildElement("dc:title");
-  if (!titleEl) {
-    Serial.println("Missing title");
-    return false;
-  }
-  this->title = titleEl->GetText();
-
-  auto cover = metadata->FirstChildElement("meta");
-  if (!cover) cover = metadata->FirstChildElement("opf:meta");
-  while (cover && cover->Attribute("name") && strcmp(cover->Attribute("name"), "cover") != 0) {
-    cover = cover->NextSiblingElement("meta");
-  }
-  if (!cover) {
-    Serial.println("Missing cover");
-  }
-  auto coverItem = cover ? cover->Attribute("content") : nullptr;
-
-  // read the manifest and spine
-  // the manifest gives us the names of the files
-  // the spine gives us the order of the files
-  // we can then read the files in the order they are in the spine
-  auto manifest = package->FirstChildElement("manifest");
-  if (!manifest) manifest = package->FirstChildElement("opf:manifest");
-  if (!manifest) {
-    Serial.println("Missing manifest");
-    return false;
-  }
-
-  // create a mapping from id to file name
-  auto item = manifest->FirstChildElement("item");
-  if (!item) item = manifest->FirstChildElement("opf:item");
-  std::map<std::string, std::string> items;
-
-  while (item) {
-    std::string itemId = item->Attribute("id");
-    std::string href = contentBasePath + item->Attribute("href");
-
-    // grab the cover image
-    if (coverItem && itemId == coverItem) {
-      coverImageItem = href;
-    }
-
-    // grab the ncx file
-    if (itemId == "ncx" || itemId == "ncxtoc") {
-      tocNcxItem = href;
-    }
-
-    items[itemId] = href;
-    auto nextItem = item->NextSiblingElement("item");
-    if (!nextItem) nextItem = item->NextSiblingElement("opf:item");
-    item = nextItem;
-  }
-
-  // find the spine
-  auto spineEl = package->FirstChildElement("spine");
-  if (!spineEl) spineEl = package->FirstChildElement("opf:spine");
-  if (!spineEl) {
-    Serial.println("Missing spine");
-    return false;
-  }
-
-  // read the spine
-  auto itemref = spineEl->FirstChildElement("itemref");
-  if (!itemref) itemref = spineEl->FirstChildElement("opf:itemref");
-  while (itemref) {
-    auto id = itemref->Attribute("idref");
-    if (items.find(id) != items.end()) {
-      spine.emplace_back(id, items[id]);
-    }
-    auto nextItemRef = itemref->NextSiblingElement("itemref");
-    if (!nextItemRef) nextItemRef = itemref->NextSiblingElement("opf:itemref");
-    itemref = nextItemRef;
-  }
   return true;
 }
 
-bool Epub::parseTocNcxFile(const ZipFile& zip) {
+bool Epub::parseContentOpf(const std::string& contentOpfFilePath) {
+  Serial.printf("[%lu] [EBP] Parsing content.opf: %s\n", millis(), contentOpfFilePath.c_str());
+
+  size_t contentOpfSize;
+  if (!getItemSize(contentOpfFilePath, &contentOpfSize)) {
+    Serial.printf("[%lu] [EBP] Could not get size of content.opf\n", millis());
+    return false;
+  }
+
+  ContentOpfParser opfParser(getBasePath(), contentOpfSize);
+
+  if (!opfParser.setup()) {
+    Serial.printf("[%lu] [EBP] Could not setup content.opf parser\n", millis());
+    return false;
+  }
+
+  if (!readItemContentsToStream(contentOpfFilePath, opfParser, 1024)) {
+    Serial.printf("[%lu] [EBP] Could not read content.opf\n", millis());
+    return false;
+  }
+
+  // Grab data from opfParser into epub
+  title = opfParser.title;
+  if (!opfParser.coverItemId.empty() && opfParser.items.count(opfParser.coverItemId) > 0) {
+    coverImageItem = opfParser.items.at(opfParser.coverItemId);
+  }
+
+  if (!opfParser.tocNcxPath.empty()) {
+    tocNcxItem = opfParser.tocNcxPath;
+  }
+
+  for (auto& spineRef : opfParser.spineRefs) {
+    if (opfParser.items.count(spineRef)) {
+      spine.emplace_back(spineRef, opfParser.items.at(spineRef));
+    }
+  }
+
+  Serial.printf("[%lu] [EBP] Successfully parsed content.opf\n", millis());
+  return true;
+}
+
+bool Epub::parseTocNcxFile() {
   // the ncx file should have been specified in the content.opf file
   if (tocNcxItem.empty()) {
-    Serial.println("No ncx file specified");
+    Serial.printf("[%lu] [EBP] No ncx file specified\n", millis());
     return false;
   }
 
-  const auto ncxData = reinterpret_cast<char*>(zip.readFileToMemory(tocNcxItem.c_str(), nullptr, true));
+  Serial.printf("[%lu] [EBP] Parsing toc ncx file: %s\n", millis(), tocNcxItem.c_str());
-  if (!ncxData) {
+
-    Serial.printf("Could not find %s\n", tocNcxItem.c_str());
+  const auto tmpNcxPath = getCachePath() + "/toc.ncx";
+  File tempNcxFile = SD.open(tmpNcxPath.c_str(), FILE_WRITE);
+  readItemContentsToStream(tocNcxItem, tempNcxFile, 1024);
+  tempNcxFile.close();
+  tempNcxFile = SD.open(tmpNcxPath.c_str(), FILE_READ);
+  const auto ncxSize = tempNcxFile.size();
+
+  TocNcxParser ncxParser(contentBasePath, ncxSize);
+
+  if (!ncxParser.setup()) {
+    Serial.printf("[%lu] [EBP] Could not setup toc ncx parser\n", millis());
     return false;
   }
 
-  // Parse the Toc contents
+  const auto ncxBuffer = static_cast<uint8_t*>(malloc(1024));
-  tinyxml2::XMLDocument doc;
+  if (!ncxBuffer) {
-  const auto result = doc.Parse(ncxData);
+    Serial.printf("[%lu] [EBP] Could not allocate memory for toc ncx parser\n", millis());
-  free(ncxData);
-
-  if (result != tinyxml2::XML_SUCCESS) {
-    Serial.printf("Error parsing toc %s\n", tinyxml2::XMLDocument::ErrorIDToName(result));
     return false;
   }
 
-  const auto ncx = doc.FirstChildElement("ncx");
+  while (tempNcxFile.available()) {
-  if (!ncx) {
+    const auto readSize = tempNcxFile.read(ncxBuffer, 1024);
-    Serial.println("Could not find first child ncx in toc");
+    const auto processedSize = ncxParser.write(ncxBuffer, readSize);
-    return false;
+
+    if (processedSize != readSize) {
+      Serial.printf("[%lu] [EBP] Could not process all toc ncx data\n", millis());
+      free(ncxBuffer);
+      tempNcxFile.close();
+      return false;
+    }
   }
 
-  const auto navMap = ncx->FirstChildElement("navMap");
+  free(ncxBuffer);
-  if (!navMap) {
+  tempNcxFile.close();
-    Serial.println("Could not find navMap child in ncx");
+  SD.remove(tmpNcxPath.c_str());
-    return false;
-  }
 
-  recursivelyParseNavMap(navMap->FirstChildElement("navPoint"));
+  this->toc = std::move(ncxParser.toc);
+
+  Serial.printf("[%lu] [EBP] Parsed %d TOC items\n", millis(), this->toc.size());
   return true;
 }
 
-void Epub::recursivelyParseNavMap(tinyxml2::XMLElement* element) {
-  // Fills toc map
-  while (element) {
-    std::string navTitle = element->FirstChildElement("navLabel")->FirstChildElement("text")->FirstChild()->Value();
-    const auto content = element->FirstChildElement("content");
-    std::string href = contentBasePath + content->Attribute("src");
-    // split the href on the # to get the href and the anchor
-    const size_t pos = href.find('#');
-    std::string anchor;
-
-    if (pos != std::string::npos) {
-      anchor = href.substr(pos + 1);
-      href = href.substr(0, pos);
-    }
-
-    toc.emplace_back(navTitle, href, anchor, 0);
-
-    tinyxml2::XMLElement* nestedNavPoint = element->FirstChildElement("navPoint");
-    if (nestedNavPoint) {
-      recursivelyParseNavMap(nestedNavPoint);
-    }
-    element = element->NextSiblingElement("navPoint");
-  }
-}
-
 // load in the meta data for the epub file
 bool Epub::load() {
-  ZipFile zip("/sd" + filepath);
+  Serial.printf("[%lu] [EBP] Loading ePub: %s\n", millis(), filepath.c_str());
 
-  std::string contentOpfFile;
+  std::string contentOpfFilePath;
-  if (!findContentOpfFile(zip, contentOpfFile)) {
+  if (!findContentOpfFile(&contentOpfFilePath)) {
-    Serial.println("Could not open ePub");
+    Serial.printf("[%lu] [EBP] Could not find content.opf in zip\n", millis());
     return false;
   }
 
-  contentBasePath = contentOpfFile.substr(0, contentOpfFile.find_last_of('/') + 1);
+  Serial.printf("[%lu] [EBP] Found content.opf at: %s\n", millis(), contentOpfFilePath.c_str());
 
-  if (!parseContentOpf(zip, contentOpfFile)) {
+  contentBasePath = contentOpfFilePath.substr(0, contentOpfFilePath.find_last_of('/') + 1);
+
+  if (!parseContentOpf(contentOpfFilePath)) {
+    Serial.printf("[%lu] [EBP] Could not parse content.opf\n", millis());
     return false;
   }
 
-  if (!parseTocNcxFile(zip)) {
+  if (!parseTocNcxFile()) {
+    Serial.printf("[%lu] [EBP] Could not parse toc\n", millis());
     return false;
   }
 
+  initializeSpineItemSizes();
+  Serial.printf("[%lu] [EBP] Loaded ePub: %s\n", millis(), filepath.c_str());
+
   return true;
 }
 
-void Epub::clearCache() const { SD.rmdir(cachePath.c_str()); }
+void Epub::initializeSpineItemSizes() {
+  Serial.printf("[%lu] [EBP] Calculating book size\n", millis());
+
+  const size_t spineItemsCount = getSpineItemsCount();
+  size_t cumSpineItemSize = 0;
+  const ZipFile zip("/sd" + filepath);
+
+  for (size_t i = 0; i < spineItemsCount; i++) {
+    std::string spineItem = getSpineItem(i);
+    size_t s = 0;
+    getItemSize(zip, spineItem, &s);
+    cumSpineItemSize += s;
+    cumulativeSpineItemSize.emplace_back(cumSpineItemSize);
+  }
+
+  Serial.printf("[%lu] [EBP] Book size: %lu\n", millis(), cumSpineItemSize);
+}
+
+bool Epub::clearCache() const {
+  if (!SD.exists(cachePath.c_str())) {
+    Serial.printf("[%lu] [EPB] Cache does not exist, no action needed\n", millis());
+    return true;
+  }
+
+  if (!FsHelpers::removeDir(cachePath.c_str())) {
+    Serial.printf("[%lu] [EPB] Failed to clear cache\n", millis());
+    return false;
+  }
+
+  Serial.printf("[%lu] [EPB] Cache cleared successfully\n", millis());
+  return true;
+}
 
 void Epub::setupCacheDir() const {
   if (SD.exists(cachePath.c_str())) {
@@ -270,7 +219,45 @@ const std::string& Epub::getPath() const { return filepath; }
 
 const std::string& Epub::getTitle() const { return title; }
 
-const std::string& Epub::getCoverImageItem() const { return coverImageItem; }
+std::string Epub::getCoverBmpPath() const { return cachePath + "/cover.bmp"; }
+
+bool Epub::generateCoverBmp() const {
+  // Already generated, return true
+  if (SD.exists(getCoverBmpPath().c_str())) {
+    return true;
+  }
+
+  if (coverImageItem.empty()) {
+    Serial.printf("[%lu] [EBP] No known cover image\n", millis());
+    return false;
+  }
+
+  if (coverImageItem.substr(coverImageItem.length() - 4) == ".jpg" ||
+      coverImageItem.substr(coverImageItem.length() - 5) == ".jpeg") {
+    Serial.printf("[%lu] [EBP] Generating BMP from JPG cover image\n", millis());
+    File coverJpg = SD.open((getCachePath() + "/.cover.jpg").c_str(), FILE_WRITE, true);
+    readItemContentsToStream(coverImageItem, coverJpg, 1024);
+    coverJpg.close();
+
+    coverJpg = SD.open((getCachePath() + "/.cover.jpg").c_str(), FILE_READ);
+    File coverBmp = SD.open(getCoverBmpPath().c_str(), FILE_WRITE, true);
+    const bool success = JpegToBmpConverter::jpegFileToBmpStream(coverJpg, coverBmp);
+    coverJpg.close();
+    coverBmp.close();
+    SD.remove((getCachePath() + "/.cover.jpg").c_str());
+
+    if (!success) {
+      Serial.printf("[%lu] [EBP] Failed to generate BMP from JPG cover image\n", millis());
+      SD.remove(getCoverBmpPath().c_str());
+    }
+    Serial.printf("[%lu] [EBP] Generated BMP from JPG cover image, success: %s\n", millis(), success ? "yes" : "no");
+    return success;
+  } else {
+    Serial.printf("[%lu] [EBP] Cover image is not a JPG, skipping\n", millis());
+  }
+
+  return false;
+}
 
 std::string normalisePath(const std::string& path) {
   std::vector<std::string> components;
@@ -314,7 +301,7 @@ uint8_t* Epub::readItemContentsToBytes(const std::string& itemHref, size_t* size
 
   const auto content = zip.readFileToMemory(path.c_str(), size, trailingNullByte);
   if (!content) {
-    Serial.printf("Failed to read item %s\n", path.c_str());
+    Serial.printf("[%lu] [EBP] Failed to read item %s\n", millis(), path.c_str());
     return nullptr;
   }
 
@@ -328,11 +315,34 @@ bool Epub::readItemContentsToStream(const std::string& itemHref, Print& out, con
   return zip.readFileToStream(path.c_str(), out, chunkSize);
 }
 
+bool Epub::getItemSize(const std::string& itemHref, size_t* size) const {
+  const ZipFile zip("/sd" + filepath);
+  return getItemSize(zip, itemHref, size);
+}
+
+bool Epub::getItemSize(const ZipFile& zip, const std::string& itemHref, size_t* size) {
+  const std::string path = normalisePath(itemHref);
+  return zip.getInflatedFileSize(path.c_str(), size);
+}
+
 int Epub::getSpineItemsCount() const { return spine.size(); }
 
+size_t Epub::getCumulativeSpineItemSize(const int spineIndex) const {
+  if (spineIndex < 0 || spineIndex >= static_cast<int>(cumulativeSpineItemSize.size())) {
+    Serial.printf("[%lu] [EBP] getCumulativeSpineItemSize index:%d is out of range\n", millis(), spineIndex);
+    return 0;
+  }
+  return cumulativeSpineItemSize.at(spineIndex);
+}
+
 std::string& Epub::getSpineItem(const int spineIndex) {
-  if (spineIndex < 0 || spineIndex >= spine.size()) {
+  static std::string emptyString;
-    Serial.printf("getSpineItem index:%d is out of range\n", spineIndex);
+  if (spine.empty()) {
+    Serial.printf("[%lu] [EBP] getSpineItem called but spine is empty\n", millis());
+    return emptyString;
+  }
+  if (spineIndex < 0 || spineIndex >= static_cast<int>(spine.size())) {
+    Serial.printf("[%lu] [EBP] getSpineItem index:%d is out of range\n", millis(), spineIndex);
     return spine.at(0).second;
   }
 
@@ -340,8 +350,13 @@ std::string& Epub::getSpineItem(const int spineIndex) {
 }
 
 EpubTocEntry& Epub::getTocItem(const int tocTndex) {
-  if (tocTndex < 0 || tocTndex >= toc.size()) {
+  static EpubTocEntry emptyEntry = {};
-    Serial.printf("getTocItem index:%d is out of range\n", tocTndex);
+  if (toc.empty()) {
+    Serial.printf("[%lu] [EBP] getTocItem called but toc is empty\n", millis());
+    return emptyEntry;
+  }
+  if (tocTndex < 0 || tocTndex >= static_cast<int>(toc.size())) {
+    Serial.printf("[%lu] [EBP] getTocItem index:%d is out of range\n", millis(), tocTndex);
     return toc.at(0);
   }
 
@@ -352,6 +367,11 @@ int Epub::getTocItemsCount() const { return toc.size(); }
 
 // work out the section index for a toc index
 int Epub::getSpineIndexForTocIndex(const int tocIndex) const {
+  if (tocIndex < 0 || tocIndex >= toc.size()) {
+    Serial.printf("[%lu] [EBP] getSpineIndexForTocIndex: tocIndex %d out of range\n", millis(), tocIndex);
+    return 0;
+  }
+
   // the toc entry should have an href that matches the spine item
   // so we can find the spine index by looking for the href
   for (int i = 0; i < spine.size(); i++) {
@@ -360,12 +380,17 @@ int Epub::getSpineIndexForTocIndex(const int tocIndex) const {
     }
   }
 
-  Serial.println("Section not found");
+  Serial.printf("[%lu] [EBP] Section not found\n", millis());
   // not found - default to the start of the book
   return 0;
 }
 
 int Epub::getTocIndexForSpineIndex(const int spineIndex) const {
+  if (spineIndex < 0 || spineIndex >= spine.size()) {
+    Serial.printf("[%lu] [EBP] getTocIndexForSpineIndex: spineIndex %d out of range\n", millis(), spineIndex);
+    return -1;
+  }
+
   // the toc entry should have an href that matches the spine item
   // so we can find the toc index by looking for the href
   for (int i = 0; i < toc.size(); i++) {
@@ -374,7 +399,25 @@ int Epub::getTocIndexForSpineIndex(const int spineIndex) const {
     }
   }
 
-  Serial.println("TOC item not found");
+  Serial.printf("[%lu] [EBP] TOC item not found\n", millis());
-  // not found - default to first item
+  return -1;
-  return 0;
+}
+
+size_t Epub::getBookSize() const {
+  if (spine.empty()) {
+    return 0;
+  }
+  return getCumulativeSpineItemSize(getSpineItemsCount() - 1);
+}
+
+// Calculate progress in book
+uint8_t Epub::calculateProgress(const int currentSpineIndex, const float currentSpineRead) {
+  size_t bookSize = getBookSize();
+  if (bookSize == 0) {
+    return 0;
+  }
+  size_t prevChapterSize = (currentSpineIndex >= 1) ? getCumulativeSpineItemSize(currentSpineIndex - 1) : 0;
+  size_t curChapterSize = getCumulativeSpineItemSize(currentSpineIndex) - prevChapterSize;
+  size_t sectionProgSize = currentSpineRead * curChapterSize;
+  return round(static_cast<float>(prevChapterSize + sectionProgSize) / bookSize * 100.0);
 }

lib/Epub/Epub.h

@@ -1,22 +1,13 @@
 #pragma once
-#include <HardwareSerial.h>
+#include <Print.h>
-#include <tinyxml2.h>
 
 #include <string>
 #include <unordered_map>
 #include <vector>
 
-class ZipFile;
+#include "Epub/EpubTocEntry.h"
 
-class EpubTocEntry {
+class ZipFile;
- public:
-  std::string title;
-  std::string href;
-  std::string anchor;
-  int level;
-  EpubTocEntry(std::string title, std::string href, std::string anchor, const int level)
-      : title(std::move(title)), href(std::move(href)), anchor(std::move(anchor)), level(level) {}
-};
 
 class Epub {
   // the title read from the EPUB meta data
@@ -29,6 +20,8 @@ class Epub {
   std::string filepath;
   // the spine of the EPUB file
   std::vector<std::pair<std::string, std::string>> spine;
+  // the file size of the spine items (proxy to book progress)
+  std::vector<size_t> cumulativeSpineItemSize;
   // the toc of the EPUB file
   std::vector<EpubTocEntry> toc;
   // the base path for items in the EPUB file
@@ -36,11 +29,11 @@ class Epub {
   // Uniq cache key based on filepath
   std::string cachePath;
 
-  // find the path for the content.opf file
+  bool findContentOpfFile(std::string* contentOpfFile) const;
-  static bool findContentOpfFile(const ZipFile& zip, std::string& contentOpfFile);
+  bool parseContentOpf(const std::string& contentOpfFilePath);
-  bool parseContentOpf(ZipFile& zip, std::string& content_opf_file);
+  bool parseTocNcxFile();
-  bool parseTocNcxFile(const ZipFile& zip);
+  void initializeSpineItemSizes();
-  void recursivelyParseNavMap(tinyxml2::XMLElement* element);
+  static bool getItemSize(const ZipFile& zip, const std::string& itemHref, size_t* size);
 
  public:
   explicit Epub(std::string filepath, const std::string& cacheDir) : filepath(std::move(filepath)) {
@@ -50,19 +43,25 @@ class Epub {
   ~Epub() = default;
   std::string& getBasePath() { return contentBasePath; }
   bool load();
-  void clearCache() const;
+  bool clearCache() const;
   void setupCacheDir() const;
   const std::string& getCachePath() const;
   const std::string& getPath() const;
   const std::string& getTitle() const;
-  const std::string& getCoverImageItem() const;
+  std::string getCoverBmpPath() const;
+  bool generateCoverBmp() const;
   uint8_t* readItemContentsToBytes(const std::string& itemHref, size_t* size = nullptr,
                                    bool trailingNullByte = false) const;
   bool readItemContentsToStream(const std::string& itemHref, Print& out, size_t chunkSize) const;
+  bool getItemSize(const std::string& itemHref, size_t* size) const;
   std::string& getSpineItem(int spineIndex);
   int getSpineItemsCount() const;
-  EpubTocEntry& getTocItem(int tocTndex);
+  size_t getCumulativeSpineItemSize(const int spineIndex) const;
+  EpubTocEntry& getTocItem(int tocIndex);
   int getTocItemsCount() const;
   int getSpineIndexForTocIndex(int tocIndex) const;
   int getTocIndexForSpineIndex(int spineIndex) const;
+
+  size_t getBookSize() const;
+  uint8_t calculateProgress(const int currentSpineIndex, const float currentSpineRead);
 };

lib/Epub/Epub/EpubHtmlParserSlim.h

@@ -1,42 +0,0 @@
-#pragma once
-
-#include <expat.h>
-#include <limits.h>
-
-#include <functional>
-
-#include "blocks/TextBlock.h"
-
-class Page;
-class EpdRenderer;
-
-#define PART_WORD_BUFFER_SIZE 200
-
-class EpubHtmlParserSlim {
-  const char* filepath;
-  EpdRenderer& renderer;
-  std::function<void(Page*)> completePageFn;
-  int depth = 0;
-  int skipUntilDepth = INT_MAX;
-  int boldUntilDepth = INT_MAX;
-  int italicUntilDepth = INT_MAX;
-  // If we encounter words longer than this, but this is pretty large
-  char partWordBuffer[PART_WORD_BUFFER_SIZE] = {};
-  int partWordBufferIndex = 0;
-  TextBlock* currentTextBlock = nullptr;
-  Page* currentPage = nullptr;
-
-  void startNewTextBlock(BLOCK_STYLE style);
-  void makePages();
-  // XML callbacks
-  static void XMLCALL startElement(void* userData, const XML_Char* name, const XML_Char** atts);
-  static void XMLCALL characterData(void* userData, const XML_Char* s, int len);
-  static void XMLCALL endElement(void* userData, const XML_Char* name);
-
- public:
-  explicit EpubHtmlParserSlim(const char* filepath, EpdRenderer& renderer,
-                              const std::function<void(Page*)>& completePageFn)
-      : filepath(filepath), renderer(renderer), completePageFn(completePageFn) {}
-  ~EpubHtmlParserSlim() = default;
-  bool parseAndBuildPages();
-};

lib/Epub/Epub/EpubTocEntry.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <string>
+
+struct EpubTocEntry {
+  std::string title;
+  std::string href;
+  std::string anchor;
+  uint8_t level;
+};

lib/Epub/Epub/FsHelpers.cpp

@@ -0,0 +1,36 @@
+#include "FsHelpers.h"
+
+#include <SD.h>
+
+bool FsHelpers::removeDir(const char* path) {
+  // 1. Open the directory
+  File dir = SD.open(path);
+  if (!dir) {
+    return false;
+  }
+  if (!dir.isDirectory()) {
+    return false;
+  }
+
+  File file = dir.openNextFile();
+  while (file) {
+    String filePath = path;
+    if (!filePath.endsWith("/")) {
+      filePath += "/";
+    }
+    filePath += file.name();
+
+    if (file.isDirectory()) {
+      if (!removeDir(filePath.c_str())) {
+        return false;
+      }
+    } else {
+      if (!SD.remove(filePath.c_str())) {
+        return false;
+      }
+    }
+    file = dir.openNextFile();
+  }
+
+  return SD.rmdir(path);
+}

lib/Epub/Epub/FsHelpers.h

@@ -0,0 +1,6 @@
+#pragma once
+
+class FsHelpers {
+ public:
+  static bool removeDir(const char* path);
+};

lib/Epub/Epub/Page.cpp

@@ -3,48 +3,58 @@
 #include <HardwareSerial.h>
 #include <Serialization.h>
 
-void PageLine::render(EpdRenderer& renderer) { block->render(renderer, 0, yPos); }
+namespace {
+constexpr uint8_t PAGE_FILE_VERSION = 3;
+}
+
+void PageLine::render(GfxRenderer& renderer, const int fontId) { block->render(renderer, fontId, xPos, yPos); }
 
 void PageLine::serialize(std::ostream& os) {
+  serialization::writePod(os, xPos);
   serialization::writePod(os, yPos);
 
   // serialize TextBlock pointed to by PageLine
   block->serialize(os);
 }
 
-PageLine* PageLine::deserialize(std::istream& is) {
+std::unique_ptr<PageLine> PageLine::deserialize(std::istream& is) {
-  int32_t yPos;
+  int16_t xPos;
+  int16_t yPos;
+  serialization::readPod(is, xPos);
   serialization::readPod(is, yPos);
 
-  const auto tb = TextBlock::deserialize(is);
+  auto tb = TextBlock::deserialize(is);
-  return new PageLine(tb, yPos);
+  return std::unique_ptr<PageLine>(new PageLine(std::move(tb), xPos, yPos));
 }
 
-void Page::render(EpdRenderer& renderer) const {
+void Page::render(GfxRenderer& renderer, const int fontId) const {
-  const auto start = millis();
+  for (auto& element : elements) {
-  for (const auto element : elements) {
+    element->render(renderer, fontId);
-    element->render(renderer);
   }
-  Serial.printf("Rendered page elements (%u) in %dms\n", elements.size(), millis() - start);
 }
 
 void Page::serialize(std::ostream& os) const {
-  serialization::writePod(os, nextY);
+  serialization::writePod(os, PAGE_FILE_VERSION);
 
   const uint32_t count = elements.size();
   serialization::writePod(os, count);
 
-  for (auto* el : elements) {
+  for (const auto& el : elements) {
     // Only PageLine exists currently
     serialization::writePod(os, static_cast<uint8_t>(TAG_PageLine));
-    static_cast<PageLine*>(el)->serialize(os);
+    el->serialize(os);
   }
 }
 
-Page* Page::deserialize(std::istream& is) {
+std::unique_ptr<Page> Page::deserialize(std::istream& is) {
-  auto* page = new Page();
+  uint8_t version;
+  serialization::readPod(is, version);
+  if (version != PAGE_FILE_VERSION) {
+    Serial.printf("[%lu] [PGE] Deserialization failed: Unknown version %u\n", millis(), version);
+    return nullptr;
+  }
 
-  serialization::readPod(is, page->nextY);
+  auto page = std::unique_ptr<Page>(new Page());
 
   uint32_t count;
   serialization::readPod(is, count);
@@ -54,10 +64,11 @@ Page* Page::deserialize(std::istream& is) {
     serialization::readPod(is, tag);
 
     if (tag == TAG_PageLine) {
-      auto* pl = PageLine::deserialize(is);
+      auto pl = PageLine::deserialize(is);
-      page->elements.push_back(pl);
+      page->elements.push_back(std::move(pl));
     } else {
-      throw std::runtime_error("Unknown PageElement tag");
+      Serial.printf("[%lu] [PGE] Deserialization failed: Unknown tag %u\n", millis(), tag);
+      return nullptr;
     }
   }
 

lib/Epub/Epub/Page.h

@@ -1,4 +1,7 @@
 #pragma once
+#include <utility>
+#include <vector>
+
 #include "blocks/TextBlock.h"
 
 enum PageElementTag : uint8_t {
@@ -8,36 +11,31 @@ enum PageElementTag : uint8_t {
 // represents something that has been added to a page
 class PageElement {
  public:
-  int yPos;
+  int16_t xPos;
-  explicit PageElement(const int yPos) : yPos(yPos) {}
+  int16_t yPos;
+  explicit PageElement(const int16_t xPos, const int16_t yPos) : xPos(xPos), yPos(yPos) {}
   virtual ~PageElement() = default;
-  virtual void render(EpdRenderer& renderer) = 0;
+  virtual void render(GfxRenderer& renderer, int fontId) = 0;
   virtual void serialize(std::ostream& os) = 0;
 };
 
 // a line from a block element
 class PageLine final : public PageElement {
-  const TextBlock* block;
+  std::shared_ptr<TextBlock> block;
 
  public:
-  PageLine(const TextBlock* block, const int yPos) : PageElement(yPos), block(block) {}
+  PageLine(std::shared_ptr<TextBlock> block, const int16_t xPos, const int16_t yPos)
-  ~PageLine() override { delete block; }
+      : PageElement(xPos, yPos), block(std::move(block)) {}
-  void render(EpdRenderer& renderer) override;
+  void render(GfxRenderer& renderer, int fontId) override;
   void serialize(std::ostream& os) override;
-  static PageLine* deserialize(std::istream& is);
+  static std::unique_ptr<PageLine> deserialize(std::istream& is);
 };
 
 class Page {
  public:
-  int nextY = 0;
   // the list of block index and line numbers on this page
-  std::vector<PageElement*> elements;
+  std::vector<std::shared_ptr<PageElement>> elements;
-  void render(EpdRenderer& renderer) const;
+  void render(GfxRenderer& renderer, int fontId) const;
-  ~Page() {
-    for (const auto element : elements) {
-      delete element;
-    }
-  }
   void serialize(std::ostream& os) const;
-  static Page* deserialize(std::istream& is);
+  static std::unique_ptr<Page> deserialize(std::istream& is);
 };

lib/Epub/Epub/ParsedText.cpp

@@ -0,0 +1,182 @@
+#include "ParsedText.h"
+
+#include <GfxRenderer.h>
+
+#include <algorithm>
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <vector>
+
+constexpr int MAX_COST = std::numeric_limits<int>::max();
+
+void ParsedText::addWord(std::string word, const EpdFontStyle fontStyle) {
+  if (word.empty()) return;
+
+  words.push_back(std::move(word));
+  wordStyles.push_back(fontStyle);
+}
+
+// Consumes data to minimize memory usage
+void ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fontId, const int horizontalMargin,
+                                       const std::function<void(std::shared_ptr<TextBlock>)>& processLine,
+                                       const bool includeLastLine) {
+  if (words.empty()) {
+    return;
+  }
+
+  const int pageWidth = renderer.getScreenWidth() - horizontalMargin;
+  const int spaceWidth = renderer.getSpaceWidth(fontId);
+  const auto wordWidths = calculateWordWidths(renderer, fontId);
+  const auto lineBreakIndices = computeLineBreaks(pageWidth, spaceWidth, wordWidths);
+  const size_t lineCount = includeLastLine ? lineBreakIndices.size() : lineBreakIndices.size() - 1;
+
+  for (size_t i = 0; i < lineCount; ++i) {
+    extractLine(i, pageWidth, spaceWidth, wordWidths, lineBreakIndices, processLine);
+  }
+}
+
+std::vector<uint16_t> ParsedText::calculateWordWidths(const GfxRenderer& renderer, const int fontId) {
+  const size_t totalWordCount = words.size();
+
+  std::vector<uint16_t> wordWidths;
+  wordWidths.reserve(totalWordCount);
+
+  // add em-space at the beginning of first word in paragraph to indent
+  if (!extraParagraphSpacing) {
+    std::string& first_word = words.front();
+    first_word.insert(0, "\xe2\x80\x83");
+  }
+
+  auto wordsIt = words.begin();
+  auto wordStylesIt = wordStyles.begin();
+
+  while (wordsIt != words.end()) {
+    wordWidths.push_back(renderer.getTextWidth(fontId, wordsIt->c_str(), *wordStylesIt));
+
+    std::advance(wordsIt, 1);
+    std::advance(wordStylesIt, 1);
+  }
+
+  return wordWidths;
+}
+
+std::vector<size_t> ParsedText::computeLineBreaks(const int pageWidth, const int spaceWidth,
+                                                  const std::vector<uint16_t>& wordWidths) const {
+  const size_t totalWordCount = words.size();
+
+  // DP table to store the minimum badness (cost) of lines starting at index i
+  std::vector<int> dp(totalWordCount);
+  // 'ans[i]' stores the index 'j' of the *last word* in the optimal line starting at 'i'
+  std::vector<size_t> ans(totalWordCount);
+
+  // Base Case
+  dp[totalWordCount - 1] = 0;
+  ans[totalWordCount - 1] = totalWordCount - 1;
+
+  for (int i = totalWordCount - 2; i >= 0; --i) {
+    int currlen = -spaceWidth;
+    dp[i] = MAX_COST;
+
+    for (size_t j = i; j < totalWordCount; ++j) {
+      // Current line length: previous width + space + current word width
+      currlen += wordWidths[j] + spaceWidth;
+
+      if (currlen > pageWidth) {
+        break;
+      }
+
+      int cost;
+      if (j == totalWordCount - 1) {
+        cost = 0;  // Last line
+      } else {
+        const int remainingSpace = pageWidth - currlen;
+        // Use long long for the square to prevent overflow
+        const long long cost_ll = static_cast<long long>(remainingSpace) * remainingSpace + dp[j + 1];
+
+        if (cost_ll > MAX_COST) {
+          cost = MAX_COST;
+        } else {
+          cost = static_cast<int>(cost_ll);
+        }
+      }
+
+      if (cost < dp[i]) {
+        dp[i] = cost;
+        ans[i] = j;  // j is the index of the last word in this optimal line
+      }
+    }
+  }
+
+  // Stores the index of the word that starts the next line (last_word_index + 1)
+  std::vector<size_t> lineBreakIndices;
+  size_t currentWordIndex = 0;
+  constexpr size_t MAX_LINES = 1000;
+
+  while (currentWordIndex < totalWordCount) {
+    if (lineBreakIndices.size() >= MAX_LINES) {
+      break;
+    }
+
+    size_t nextBreakIndex = ans[currentWordIndex] + 1;
+    lineBreakIndices.push_back(nextBreakIndex);
+
+    currentWordIndex = nextBreakIndex;
+  }
+
+  return lineBreakIndices;
+}
+
+void ParsedText::extractLine(const size_t breakIndex, const int pageWidth, const int spaceWidth,
+                             const std::vector<uint16_t>& wordWidths, const std::vector<size_t>& lineBreakIndices,
+                             const std::function<void(std::shared_ptr<TextBlock>)>& processLine) {
+  const size_t lineBreak = lineBreakIndices[breakIndex];
+  const size_t lastBreakAt = breakIndex > 0 ? lineBreakIndices[breakIndex - 1] : 0;
+  const size_t lineWordCount = lineBreak - lastBreakAt;
+
+  // Calculate total word width for this line
+  int lineWordWidthSum = 0;
+  for (size_t i = lastBreakAt; i < lineBreak; i++) {
+    lineWordWidthSum += wordWidths[i];
+  }
+
+  // Calculate spacing
+  const int spareSpace = pageWidth - lineWordWidthSum;
+
+  int spacing = spaceWidth;
+  const bool isLastLine = breakIndex == lineBreakIndices.size() - 1;
+
+  if (style == TextBlock::JUSTIFIED && !isLastLine && lineWordCount >= 2) {
+    spacing = spareSpace / (lineWordCount - 1);
+  }
+
+  // Calculate initial x position
+  uint16_t xpos = 0;
+  if (style == TextBlock::RIGHT_ALIGN) {
+    xpos = spareSpace - (lineWordCount - 1) * spaceWidth;
+  } else if (style == TextBlock::CENTER_ALIGN) {
+    xpos = (spareSpace - (lineWordCount - 1) * spaceWidth) / 2;
+  }
+
+  // Pre-calculate X positions for words
+  std::list<uint16_t> lineXPos;
+  for (size_t i = lastBreakAt; i < lineBreak; i++) {
+    const uint16_t currentWordWidth = wordWidths[i];
+    lineXPos.push_back(xpos);
+    xpos += currentWordWidth + spacing;
+  }
+
+  // Iterators always start at the beginning as we are moving content with splice below
+  auto wordEndIt = words.begin();
+  auto wordStyleEndIt = wordStyles.begin();
+  std::advance(wordEndIt, lineWordCount);
+  std::advance(wordStyleEndIt, lineWordCount);
+
+  // *** CRITICAL STEP: CONSUME DATA USING SPLICE ***
+  std::list<std::string> lineWords;
+  lineWords.splice(lineWords.begin(), words, words.begin(), wordEndIt);
+  std::list<EpdFontStyle> lineWordStyles;
+  lineWordStyles.splice(lineWordStyles.begin(), wordStyles, wordStyles.begin(), wordStyleEndIt);
+
+  processLine(std::make_shared<TextBlock>(std::move(lineWords), std::move(lineXPos), std::move(lineWordStyles), style));
+}

lib/Epub/Epub/ParsedText.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <EpdFontFamily.h>
+
+#include <functional>
+#include <list>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "blocks/TextBlock.h"
+
+class GfxRenderer;
+
+class ParsedText {
+  std::list<std::string> words;
+  std::list<EpdFontStyle> wordStyles;
+  TextBlock::BLOCK_STYLE style;
+  bool extraParagraphSpacing;
+
+  std::vector<size_t> computeLineBreaks(int pageWidth, int spaceWidth, const std::vector<uint16_t>& wordWidths) const;
+  void extractLine(size_t breakIndex, int pageWidth, int spaceWidth, const std::vector<uint16_t>& wordWidths,
+                   const std::vector<size_t>& lineBreakIndices,
+                   const std::function<void(std::shared_ptr<TextBlock>)>& processLine);
+  std::vector<uint16_t> calculateWordWidths(const GfxRenderer& renderer, int fontId);
+
+ public:
+  explicit ParsedText(const TextBlock::BLOCK_STYLE style, const bool extraParagraphSpacing)
+      : style(style), extraParagraphSpacing(extraParagraphSpacing) {}
+  ~ParsedText() = default;
+
+  void addWord(std::string word, EpdFontStyle fontStyle);
+  void setStyle(const TextBlock::BLOCK_STYLE style) { this->style = style; }
+  TextBlock::BLOCK_STYLE getStyle() const { return style; }
+  size_t size() const { return words.size(); }
+  bool isEmpty() const { return words.empty(); }
+  void layoutAndExtractLines(const GfxRenderer& renderer, int fontId, int horizontalMargin,
+                             const std::function<void(std::shared_ptr<TextBlock>)>& processLine,
+                             bool includeLastLine = true);
+};

lib/Epub/Epub/Section.cpp

@@ -1,37 +1,49 @@
 #include "Section.h"
 
-#include <EpdRenderer.h>
 #include <SD.h>
+#include <Serialization.h>
 
 #include <fstream>
 
-#include "EpubHtmlParserSlim.h"
+#include "FsHelpers.h"
 #include "Page.h"
-#include "Serialization.h"
+#include "parsers/ChapterHtmlSlimParser.h"
 
-constexpr uint8_t SECTION_FILE_VERSION = 2;
+namespace {
-
+constexpr uint8_t SECTION_FILE_VERSION = 5;
-void Section::onPageComplete(const Page* page) {
+}
-  Serial.printf("Page %d complete - free mem: %lu\n", pageCount, ESP.getFreeHeap());
 
+void Section::onPageComplete(std::unique_ptr<Page> page) {
   const auto filePath = cachePath + "/page_" + std::to_string(pageCount) + ".bin";
 
   std::ofstream outputFile("/sd" + filePath);
   page->serialize(outputFile);
   outputFile.close();
 
+  Serial.printf("[%lu] [SCT] Page %d processed\n", millis(), pageCount);
+
   pageCount++;
-  delete page;
 }
 
-void Section::writeCacheMetadata() const {
+void Section::writeCacheMetadata(const int fontId, const float lineCompression, const int marginTop,
+                                 const int marginRight, const int marginBottom, const int marginLeft,
+                                 const bool extraParagraphSpacing) const {
   std::ofstream outputFile(("/sd" + cachePath + "/section.bin").c_str());
   serialization::writePod(outputFile, SECTION_FILE_VERSION);
+  serialization::writePod(outputFile, fontId);
+  serialization::writePod(outputFile, lineCompression);
+  serialization::writePod(outputFile, marginTop);
+  serialization::writePod(outputFile, marginRight);
+  serialization::writePod(outputFile, marginBottom);
+  serialization::writePod(outputFile, marginLeft);
+  serialization::writePod(outputFile, extraParagraphSpacing);
   serialization::writePod(outputFile, pageCount);
   outputFile.close();
 }
 
-bool Section::loadCacheMetadata() {
+bool Section::loadCacheMetadata(const int fontId, const float lineCompression, const int marginTop,
+                                const int marginRight, const int marginBottom, const int marginLeft,
+                                const bool extraParagraphSpacing) {
   if (!SD.exists(cachePath.c_str())) {
     return false;
   }
@@ -42,17 +54,42 @@ bool Section::loadCacheMetadata() {
   }
 
   std::ifstream inputFile(("/sd" + sectionFilePath).c_str());
-  uint8_t version;
+
-  serialization::readPod(inputFile, version);
+  // Match parameters
-  if (version != SECTION_FILE_VERSION) {
+  {
-    inputFile.close();
+    uint8_t version;
-    SD.remove(sectionFilePath.c_str());
+    serialization::readPod(inputFile, version);
-    Serial.printf("Section state file: Unknown version %u\n", version);
+    if (version != SECTION_FILE_VERSION) {
-    return false;
+      inputFile.close();
+      Serial.printf("[%lu] [SCT] Deserialization failed: Unknown version %u\n", millis(), version);
+      clearCache();
+      return false;
+    }
+
+    int fileFontId, fileMarginTop, fileMarginRight, fileMarginBottom, fileMarginLeft;
+    float fileLineCompression;
+    bool fileExtraParagraphSpacing;
+    serialization::readPod(inputFile, fileFontId);
+    serialization::readPod(inputFile, fileLineCompression);
+    serialization::readPod(inputFile, fileMarginTop);
+    serialization::readPod(inputFile, fileMarginRight);
+    serialization::readPod(inputFile, fileMarginBottom);
+    serialization::readPod(inputFile, fileMarginLeft);
+    serialization::readPod(inputFile, fileExtraParagraphSpacing);
+
+    if (fontId != fileFontId || lineCompression != fileLineCompression || marginTop != fileMarginTop ||
+        marginRight != fileMarginRight || marginBottom != fileMarginBottom || marginLeft != fileMarginLeft ||
+        extraParagraphSpacing != fileExtraParagraphSpacing) {
+      inputFile.close();
+      Serial.printf("[%lu] [SCT] Deserialization failed: Parameters do not match\n", millis());
+      clearCache();
+      return false;
+    }
   }
+
   serialization::readPod(inputFile, pageCount);
   inputFile.close();
-  Serial.printf("Loaded cache: %d pages\n", pageCount);
+  Serial.printf("[%lu] [SCT] Deserialization succeeded: %d pages\n", millis(), pageCount);
   return true;
 }
 
@@ -61,9 +98,25 @@ void Section::setupCacheDir() const {
   SD.mkdir(cachePath.c_str());
 }
 
-void Section::clearCache() const { SD.rmdir(cachePath.c_str()); }
+// Your updated class method (assuming you are using the 'SD' object, which is a wrapper for a specific filesystem)
+bool Section::clearCache() const {
+  if (!SD.exists(cachePath.c_str())) {
+    Serial.printf("[%lu] [SCT] Cache does not exist, no action needed\n", millis());
+    return true;
+  }
 
-bool Section::persistPageDataToSD() {
+  if (!FsHelpers::removeDir(cachePath.c_str())) {
+    Serial.printf("[%lu] [SCT] Failed to clear cache\n", millis());
+    return false;
+  }
+
+  Serial.printf("[%lu] [SCT] Cache cleared successfully\n", millis());
+  return true;
+}
+
+bool Section::persistPageDataToSD(const int fontId, const float lineCompression, const int marginTop,
+                                  const int marginRight, const int marginBottom, const int marginLeft,
+                                  const bool extraParagraphSpacing) {
   const auto localPath = epub->getSpineItem(spineIndex);
 
   // TODO: Should we get rid of this file all together?
@@ -75,44 +128,39 @@ bool Section::persistPageDataToSD() {
   f.close();
 
   if (!success) {
-    Serial.println("Failed to stream item contents");
+    Serial.printf("[%lu] [SCT] Failed to stream item contents to temp file\n", millis());
     return false;
   }
 
-  Serial.printf("Streamed HTML to %s\n", tmpHtmlPath.c_str());
+  Serial.printf("[%lu] [SCT] Streamed temp HTML to %s\n", millis(), tmpHtmlPath.c_str());
 
   const auto sdTmpHtmlPath = "/sd" + tmpHtmlPath;
 
-  auto visitor =
+  ChapterHtmlSlimParser visitor(sdTmpHtmlPath.c_str(), renderer, fontId, lineCompression, marginTop, marginRight,
-      EpubHtmlParserSlim(sdTmpHtmlPath.c_str(), renderer, [this](const Page* page) { this->onPageComplete(page); });
+                                marginBottom, marginLeft, extraParagraphSpacing,
+                                [this](std::unique_ptr<Page> page) { this->onPageComplete(std::move(page)); });
   success = visitor.parseAndBuildPages();
 
   SD.remove(tmpHtmlPath.c_str());
   if (!success) {
-    Serial.println("Failed to parse and build pages");
+    Serial.printf("[%lu] [SCT] Failed to parse XML and build pages\n", millis());
     return false;
   }
 
-  writeCacheMetadata();
+  writeCacheMetadata(fontId, lineCompression, marginTop, marginRight, marginBottom, marginLeft, extraParagraphSpacing);
 
   return true;
 }
 
-void Section::renderPage() const {
+std::unique_ptr<Page> Section::loadPageFromSD() const {
-  if (0 <= currentPage && currentPage < pageCount) {
+  const auto filePath = "/sd" + cachePath + "/page_" + std::to_string(currentPage) + ".bin";
-    const auto filePath = "/sd" + cachePath + "/page_" + std::to_string(currentPage) + ".bin";
+  if (!SD.exists(filePath.c_str() + 3)) {
-    std::ifstream inputFile(filePath);
+    Serial.printf("[%lu] [SCT] Page file does not exist: %s\n", millis(), filePath.c_str());
-    const Page* p = Page::deserialize(inputFile);
+    return nullptr;
-    inputFile.close();
-    p->render(renderer);
-    delete p;
-  } else if (pageCount == 0) {
-    Serial.println("No pages to render");
-    const int width = renderer.getTextWidth("Empty chapter", BOLD);
-    renderer.drawText((renderer.getPageWidth() - width) / 2, 300, "Empty chapter", 1, BOLD);
-  } else {
-    Serial.printf("Page out of bounds: %d (max %d)\n", currentPage, pageCount);
-    const int width = renderer.getTextWidth("Out of bounds", BOLD);
-    renderer.drawText((renderer.getPageWidth() - width) / 2, 300, "Out of bounds", 1, BOLD);
   }
+
+  std::ifstream inputFile(filePath);
+  auto page = Page::deserialize(inputFile);
+  inputFile.close();
+  return page;
 }

lib/Epub/Epub/Section.h

@@ -1,30 +1,36 @@
 #pragma once
+#include <memory>
+
 #include "Epub.h"
 
 class Page;
-class EpdRenderer;
+class GfxRenderer;
 
 class Section {
-  Epub* epub;
+  std::shared_ptr<Epub> epub;
   const int spineIndex;
-  EpdRenderer& renderer;
+  GfxRenderer& renderer;
   std::string cachePath;
 
-  void onPageComplete(const Page* page);
+  void writeCacheMetadata(int fontId, float lineCompression, int marginTop, int marginRight, int marginBottom,
+                          int marginLeft, bool extraParagraphSpacing) const;
+  void onPageComplete(std::unique_ptr<Page> page);
 
  public:
   int pageCount = 0;
   int currentPage = 0;
 
-  explicit Section(Epub* epub, const int spineIndex, EpdRenderer& renderer)
+  explicit Section(const std::shared_ptr<Epub>& epub, const int spineIndex, GfxRenderer& renderer)
-      : epub(epub), spineIndex(spineIndex), renderer(renderer) {
+      : epub(epub),
-    cachePath = epub->getCachePath() + "/" + std::to_string(spineIndex);
+        spineIndex(spineIndex),
-  }
+        renderer(renderer),
+        cachePath(epub->getCachePath() + "/" + std::to_string(spineIndex)) {}
   ~Section() = default;
-  void writeCacheMetadata() const;
+  bool loadCacheMetadata(int fontId, float lineCompression, int marginTop, int marginRight, int marginBottom,
-  bool loadCacheMetadata();
+                         int marginLeft, bool extraParagraphSpacing);
   void setupCacheDir() const;
-  void clearCache() const;
+  bool clearCache() const;
-  bool persistPageDataToSD();
+  bool persistPageDataToSD(int fontId, float lineCompression, int marginTop, int marginRight, int marginBottom,
-  void renderPage() const;
+                           int marginLeft, bool extraParagraphSpacing);
+  std::unique_ptr<Page> loadPageFromSD() const;
 };

lib/Epub/Epub/blocks/Block.h

@@ -1,6 +1,6 @@
 #pragma once
 
-class EpdRenderer;
+class GfxRenderer;
 
 typedef enum { TEXT_BLOCK, IMAGE_BLOCK } BlockType;
 
@@ -8,7 +8,7 @@ typedef enum { TEXT_BLOCK, IMAGE_BLOCK } BlockType;
 class Block {
  public:
   virtual ~Block() = default;
-  virtual void layout(EpdRenderer& renderer) = 0;
+  virtual void layout(GfxRenderer& renderer) = 0;
   virtual BlockType getType() = 0;
   virtual bool isEmpty() = 0;
   virtual void finish() {}

lib/Epub/Epub/blocks/TextBlock.cpp

@@ -1,171 +1,19 @@
 #include "TextBlock.h"
 
-#include <EpdRenderer.h>
+#include <GfxRenderer.h>
 #include <Serialization.h>
 
-void TextBlock::addWord(const std::string& word, const bool is_bold, const bool is_italic) {
+void TextBlock::render(const GfxRenderer& renderer, const int fontId, const int x, const int y) const {
-  if (word.length() == 0) return;
+  auto wordIt = words.begin();
+  auto wordStylesIt = wordStyles.begin();
+  auto wordXposIt = wordXpos.begin();
 
-  words.push_back(word);
-  wordStyles.push_back((is_bold ? BOLD_SPAN : 0) | (is_italic ? ITALIC_SPAN : 0));
-}
-
-std::list<TextBlock*> TextBlock::splitIntoLines(const EpdRenderer& renderer) {
-  const int totalWordCount = words.size();
-  const int pageWidth = renderer.getPageWidth();
-  const int spaceWidth = renderer.getSpaceWidth();
-
-  words.shrink_to_fit();
-  wordStyles.shrink_to_fit();
-  wordXpos.reserve(totalWordCount);
-
-  // measure each word
-  uint16_t wordWidths[totalWordCount];
   for (int i = 0; i < words.size(); i++) {
-    // measure the word
+    renderer.drawText(fontId, *wordXposIt + x, y, wordIt->c_str(), true, *wordStylesIt);
-    EpdFontStyle fontStyle = REGULAR;
-    if (wordStyles[i] & BOLD_SPAN) {
-      if (wordStyles[i] & ITALIC_SPAN) {
-        fontStyle = BOLD_ITALIC;
-      } else {
-        fontStyle = BOLD;
-      }
-    } else if (wordStyles[i] & ITALIC_SPAN) {
-      fontStyle = ITALIC;
-    }
-    const int width = renderer.getTextWidth(words[i].c_str(), fontStyle);
-    wordWidths[i] = width;
-  }
 
-  // now apply the dynamic programming algorithm to find the best line breaks
+    std::advance(wordIt, 1);
-  // DP table in which dp[i] represents cost of line starting with word words[i]
+    std::advance(wordStylesIt, 1);
-  int dp[totalWordCount];
+    std::advance(wordXposIt, 1);
-
-  // Array in which ans[i] store index of last word in line starting with word
-  // word[i]
-  size_t ans[totalWordCount];
-
-  // If only one word is present then only one line is required. Cost of last
-  // line is zero. Hence cost of this line is zero. Ending point is also n-1 as
-  // single word is present
-  dp[totalWordCount - 1] = 0;
-  ans[totalWordCount - 1] = totalWordCount - 1;
-
-  // Make each word first word of line by iterating over each index in arr.
-  for (int i = totalWordCount - 2; i >= 0; i--) {
-    int currlen = -1;
-    dp[i] = INT_MAX;
-
-    // Variable to store possible minimum cost of line.
-    int cost;
-
-    // Keep on adding words in current line by iterating from starting word upto
-    // last word in arr.
-    for (int j = i; j < totalWordCount; j++) {
-      // Update the width of the words in current line + the space between two
-      // words.
-      currlen += wordWidths[j] + spaceWidth;
-
-      // If we're bigger than the current pagewidth then we can't add more words
-      if (currlen > pageWidth) break;
-
-      // if we've run out of words then this is last line and the cost should be
-      // 0 Otherwise the cost is the sqaure of the left over space + the costs
-      // of all the previous lines
-      if (j == totalWordCount - 1)
-        cost = 0;
-      else
-        cost = (pageWidth - currlen) * (pageWidth - currlen) + dp[j + 1];
-
-      // Check if this arrangement gives minimum cost for line starting with
-      // word words[i].
-      if (cost < dp[i]) {
-        dp[i] = cost;
-        ans[i] = j;
-      }
-    }
-  }
-
-  // We can now iterate through the answer to find the line break positions
-  std::list<uint16_t> lineBreaks;
-  for (size_t i = 0; i < totalWordCount;) {
-    i = ans[i] + 1;
-    if (i > totalWordCount) {
-      break;
-    }
-    lineBreaks.push_back(i);
-    // Text too big, just exit
-    if (lineBreaks.size() > 1000) {
-      break;
-    }
-  }
-
-  std::list<TextBlock*> lines;
-
-  // With the line breaks calculated we can now position the words along the
-  // line
-  int startWord = 0;
-  for (const auto lineBreak : lineBreaks) {
-    const int lineWordCount = lineBreak - startWord;
-
-    int lineWordWidthSum = 0;
-    for (int i = startWord; i < lineBreak; i++) {
-      lineWordWidthSum += wordWidths[i];
-    }
-
-    // Calculate spacing between words
-    const uint16_t spareSpace = pageWidth - lineWordWidthSum;
-    uint16_t spacing = spaceWidth;
-    // evenly space words if using justified style, not the last line, and at
-    // least 2 words
-    if (style == JUSTIFIED && lineBreak != lineBreaks.back() && lineWordCount >= 2) {
-      spacing = spareSpace / (lineWordCount - 1);
-    }
-
-    uint16_t xpos = 0;
-    if (style == RIGHT_ALIGN) {
-      xpos = spareSpace - (lineWordCount - 1) * spaceWidth;
-    } else if (style == CENTER_ALIGN) {
-      xpos = (spareSpace - (lineWordCount - 1) * spaceWidth) / 2;
-    }
-
-    for (int i = startWord; i < lineBreak; i++) {
-      wordXpos[i] = xpos;
-      xpos += wordWidths[i] + spacing;
-    }
-
-    std::vector<std::string> lineWords;
-    std::vector<uint16_t> lineXPos;
-    std::vector<uint8_t> lineWordStyles;
-    lineWords.reserve(lineWordCount);
-    lineXPos.reserve(lineWordCount);
-    lineWordStyles.reserve(lineWordCount);
-
-    for (int i = startWord; i < lineBreak; i++) {
-      lineWords.push_back(words[i]);
-      lineXPos.push_back(wordXpos[i]);
-      lineWordStyles.push_back(wordStyles[i]);
-    }
-    const auto textLine = new TextBlock(lineWords, lineXPos, lineWordStyles, style);
-    lines.push_back(textLine);
-    startWord = lineBreak;
-  }
-
-  return lines;
-}
-
-void TextBlock::render(const EpdRenderer& renderer, const int x, const int y) const {
-  for (int i = 0; i < words.size(); i++) {
-    // render the word
-    EpdFontStyle fontStyle = REGULAR;
-    if (wordStyles[i] & BOLD_SPAN && wordStyles[i] & ITALIC_SPAN) {
-      fontStyle = BOLD_ITALIC;
-    } else if (wordStyles[i] & BOLD_SPAN) {
-      fontStyle = BOLD;
-    } else if (wordStyles[i] & ITALIC_SPAN) {
-      fontStyle = ITALIC;
-    }
-    renderer.drawText(x + wordXpos[i], y, words[i].c_str(), 1, fontStyle);
   }
 }
 
@@ -189,11 +37,11 @@ void TextBlock::serialize(std::ostream& os) const {
   serialization::writePod(os, style);
 }
 
-TextBlock* TextBlock::deserialize(std::istream& is) {
+std::unique_ptr<TextBlock> TextBlock::deserialize(std::istream& is) {
   uint32_t wc, xc, sc;
-  std::vector<std::string> words;
+  std::list<std::string> words;
-  std::vector<uint16_t> wordXpos;
+  std::list<uint16_t> wordXpos;
-  std::vector<uint8_t> wordStyles;
+  std::list<EpdFontStyle> wordStyles;
   BLOCK_STYLE style;
 
   // words
@@ -214,5 +62,5 @@ TextBlock* TextBlock::deserialize(std::istream& is) {
   // style
   serialization::readPod(is, style);
 
-  return new TextBlock(words, wordXpos, wordStyles, style);
+  return std::unique_ptr<TextBlock>(new TextBlock(std::move(words), std::move(wordXpos), std::move(wordStyles), style));
 }

lib/Epub/Epub/blocks/TextBlock.h

@@ -1,50 +1,40 @@
 #pragma once
+#include <EpdFontFamily.h>
+
 #include <list>
+#include <memory>
 #include <string>
-#include <vector>
 
 #include "Block.h"
 
-enum SPAN_STYLE : uint8_t {
-  BOLD_SPAN = 1,
-  ITALIC_SPAN = 2,
-};
-
-enum BLOCK_STYLE : uint8_t {
-  JUSTIFIED = 0,
-  LEFT_ALIGN = 1,
-  CENTER_ALIGN = 2,
-  RIGHT_ALIGN = 3,
-};
-
 // represents a block of words in the html document
 class TextBlock final : public Block {
-  // pointer to each word
+ public:
-  std::vector<std::string> words;
+  enum BLOCK_STYLE : uint8_t {
-  // x position of each word
+    JUSTIFIED = 0,
-  std::vector<uint16_t> wordXpos;
+    LEFT_ALIGN = 1,
-  // the styles of each word
+    CENTER_ALIGN = 2,
-  std::vector<uint8_t> wordStyles;
+    RIGHT_ALIGN = 3,
+  };
 
-  // the style of the block - left, center, right aligned
+ private:
+  std::list<std::string> words;
+  std::list<uint16_t> wordXpos;
+  std::list<EpdFontStyle> wordStyles;
   BLOCK_STYLE style;
 
  public:
-  explicit TextBlock(const BLOCK_STYLE style) : style(style) {}
+  explicit TextBlock(std::list<std::string> words, std::list<uint16_t> word_xpos, std::list<EpdFontStyle> word_styles,
-  explicit TextBlock(const std::vector<std::string>& words, const std::vector<uint16_t>& word_xpos,
+                     const BLOCK_STYLE style)
-                     // the styles of each word
+      : words(std::move(words)), wordXpos(std::move(word_xpos)), wordStyles(std::move(word_styles)), style(style) {}
-                     const std::vector<uint8_t>& word_styles, const BLOCK_STYLE style)
-      : words(words), wordXpos(word_xpos), wordStyles(word_styles), style(style) {}
   ~TextBlock() override = default;
-  void addWord(const std::string& word, bool is_bold, bool is_italic);
   void setStyle(const BLOCK_STYLE style) { this->style = style; }
   BLOCK_STYLE getStyle() const { return style; }
   bool isEmpty() override { return words.empty(); }
-  void layout(EpdRenderer& renderer) override {};
+  void layout(GfxRenderer& renderer) override {};
   // given a renderer works out where to break the words into lines
-  std::list<TextBlock*> splitIntoLines(const EpdRenderer& renderer);
+  void render(const GfxRenderer& renderer, int fontId, int x, int y) const;
-  void render(const EpdRenderer& renderer, int x, int y) const;
   BlockType getType() override { return TEXT_BLOCK; }
   void serialize(std::ostream& os) const;
-  static TextBlock* deserialize(std::istream& is);
+  static std::unique_ptr<TextBlock> deserialize(std::istream& is);
 };

lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp

@@ -1,11 +1,11 @@
-#include "EpubHtmlParserSlim.h"
+#include "ChapterHtmlSlimParser.h"
 
-#include <EpdRenderer.h>
+#include <GfxRenderer.h>
 #include <HardwareSerial.h>
 #include <expat.h>
 
-#include "Page.h"
+#include "../Page.h"
-#include "htmlEntities.h"
+#include "../htmlEntities.h"
 
 const char* HEADER_TAGS[] = {"h1", "h2", "h3", "h4", "h5", "h6"};
 constexpr int NUM_HEADER_TAGS = sizeof(HEADER_TAGS) / sizeof(HEADER_TAGS[0]);
@@ -25,7 +25,7 @@ constexpr int NUM_IMAGE_TAGS = sizeof(IMAGE_TAGS) / sizeof(IMAGE_TAGS[0]);
 const char* SKIP_TAGS[] = {"head", "table"};
 constexpr int NUM_SKIP_TAGS = sizeof(SKIP_TAGS) / sizeof(SKIP_TAGS[0]);
 
-bool isWhitespace(const char c) { return c == ' ' || c == '\r' || c == '\n'; }
+bool isWhitespace(const char c) { return c == ' ' || c == '\r' || c == '\n' || c == '\t'; }
 
 // given the start and end of a tag, check to see if it matches a known tag
 bool matches(const char* tag_name, const char* possible_tags[], const int possible_tag_count) {
@@ -38,7 +38,7 @@ bool matches(const char* tag_name, const char* possible_tags[], const int possib
 }
 
 // start a new text block if needed
-void EpubHtmlParserSlim::startNewTextBlock(const BLOCK_STYLE style) {
+void ChapterHtmlSlimParser::startNewTextBlock(const TextBlock::BLOCK_STYLE style) {
   if (currentTextBlock) {
     // already have a text block running and it is empty - just reuse it
     if (currentTextBlock->isEmpty()) {
@@ -46,15 +46,13 @@ void EpubHtmlParserSlim::startNewTextBlock(const BLOCK_STYLE style) {
       return;
     }
 
-    currentTextBlock->finish();
     makePages();
-    delete currentTextBlock;
   }
-  currentTextBlock = new TextBlock(style);
+  currentTextBlock.reset(new ParsedText(style, extraParagraphSpacing));
 }
 
-void XMLCALL EpubHtmlParserSlim::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
+void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
-  auto* self = static_cast<EpubHtmlParserSlim*>(userData);
+  auto* self = static_cast<ChapterHtmlSlimParser*>(userData);
   (void)atts;
 
   // Middle of skip
@@ -64,23 +62,7 @@ void XMLCALL EpubHtmlParserSlim::startElement(void* userData, const XML_Char* na
   }
 
   if (matches(name, IMAGE_TAGS, NUM_IMAGE_TAGS)) {
-    // const char* src = element.Attribute("src");
+    // TODO: Start processing image tags
-    // if (src) {
-    //   // don't leave an empty text block in the list
-    //   // const BLOCK_STYLE style = currentTextBlock->get_style();
-    //   if (currentTextBlock->isEmpty()) {
-    //     delete currentTextBlock;
-    //     currentTextBlock = nullptr;
-    //   }
-    //   // TODO: Fix this
-    //   // blocks.push_back(new ImageBlock(m_base_path + src));
-    //   // start a new text block - with the same style as before
-    //   // startNewTextBlock(style);
-    // } else {
-    //   // ESP_LOGE(TAG, "Could not find src attribute");
-    // }
-
-    // start skip
     self->skipUntilDepth = self->depth;
     self->depth += 1;
     return;
@@ -93,14 +75,26 @@ void XMLCALL EpubHtmlParserSlim::startElement(void* userData, const XML_Char* na
     return;
   }
 
+  // Skip blocks with role="doc-pagebreak" and epub:type="pagebreak"
+  if (atts != nullptr) {
+    for (int i = 0; atts[i]; i += 2) {
+      if (strcmp(atts[i], "role") == 0 && strcmp(atts[i + 1], "doc-pagebreak") == 0 ||
+          strcmp(atts[i], "epub:type") == 0 && strcmp(atts[i + 1], "pagebreak") == 0) {
+        self->skipUntilDepth = self->depth;
+        self->depth += 1;
+        return;
+      }
+    }
+  }
+
   if (matches(name, HEADER_TAGS, NUM_HEADER_TAGS)) {
-    self->startNewTextBlock(CENTER_ALIGN);
+    self->startNewTextBlock(TextBlock::CENTER_ALIGN);
     self->boldUntilDepth = min(self->boldUntilDepth, self->depth);
   } else if (matches(name, BLOCK_TAGS, NUM_BLOCK_TAGS)) {
     if (strcmp(name, "br") == 0) {
       self->startNewTextBlock(self->currentTextBlock->getStyle());
     } else {
-      self->startNewTextBlock(JUSTIFIED);
+      self->startNewTextBlock(TextBlock::JUSTIFIED);
     }
   } else if (matches(name, BOLD_TAGS, NUM_BOLD_TAGS)) {
     self->boldUntilDepth = min(self->boldUntilDepth, self->depth);
@@ -111,21 +105,29 @@ void XMLCALL EpubHtmlParserSlim::startElement(void* userData, const XML_Char* na
   self->depth += 1;
 }
 
-void XMLCALL EpubHtmlParserSlim::characterData(void* userData, const XML_Char* s, const int len) {
+void XMLCALL ChapterHtmlSlimParser::characterData(void* userData, const XML_Char* s, const int len) {
-  auto* self = static_cast<EpubHtmlParserSlim*>(userData);
+  auto* self = static_cast<ChapterHtmlSlimParser*>(userData);
 
   // Middle of skip
   if (self->skipUntilDepth < self->depth) {
     return;
   }
 
+  EpdFontStyle fontStyle = REGULAR;
+  if (self->boldUntilDepth < self->depth && self->italicUntilDepth < self->depth) {
+    fontStyle = BOLD_ITALIC;
+  } else if (self->boldUntilDepth < self->depth) {
+    fontStyle = BOLD;
+  } else if (self->italicUntilDepth < self->depth) {
+    fontStyle = ITALIC;
+  }
+
   for (int i = 0; i < len; i++) {
     if (isWhitespace(s[i])) {
       // Currently looking at whitespace, if there's anything in the partWordBuffer, flush it
       if (self->partWordBufferIndex > 0) {
         self->partWordBuffer[self->partWordBufferIndex] = '\0';
-        self->currentTextBlock->addWord(replaceHtmlEntities(self->partWordBuffer), self->boldUntilDepth < self->depth,
+        self->currentTextBlock->addWord(std::move(replaceHtmlEntities(self->partWordBuffer)), fontStyle);
-                                        self->italicUntilDepth < self->depth);
         self->partWordBufferIndex = 0;
       }
       // Skip the whitespace char
@@ -133,19 +135,29 @@ void XMLCALL EpubHtmlParserSlim::characterData(void* userData, const XML_Char* s
     }
 
     // If we're about to run out of space, then cut the word off and start a new one
-    if (self->partWordBufferIndex >= PART_WORD_BUFFER_SIZE - 2) {
+    if (self->partWordBufferIndex >= MAX_WORD_SIZE) {
       self->partWordBuffer[self->partWordBufferIndex] = '\0';
-      self->currentTextBlock->addWord(replaceHtmlEntities(self->partWordBuffer), self->boldUntilDepth < self->depth,
+      self->currentTextBlock->addWord(std::move(replaceHtmlEntities(self->partWordBuffer)), fontStyle);
-                                      self->italicUntilDepth < self->depth);
       self->partWordBufferIndex = 0;
     }
 
     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) {
+    Serial.printf("[%lu] [EHP] Text block too long, splitting into multiple pages\n", millis());
+    self->currentTextBlock->layoutAndExtractLines(
+        self->renderer, self->fontId, self->marginLeft + self->marginRight,
+        [self](const std::shared_ptr<TextBlock>& textBlock) { self->addLineToPage(textBlock); }, false);
+  }
 }
 
-void XMLCALL EpubHtmlParserSlim::endElement(void* userData, const XML_Char* name) {
+void XMLCALL ChapterHtmlSlimParser::endElement(void* userData, const XML_Char* name) {
-  auto* self = static_cast<EpubHtmlParserSlim*>(userData);
+  auto* self = static_cast<ChapterHtmlSlimParser*>(userData);
   (void)name;
 
   if (self->partWordBufferIndex > 0) {
@@ -158,9 +170,17 @@ void XMLCALL EpubHtmlParserSlim::endElement(void* userData, const XML_Char* name
         matches(name, BOLD_TAGS, NUM_BOLD_TAGS) || matches(name, ITALIC_TAGS, NUM_ITALIC_TAGS) || self->depth == 1;
 
     if (shouldBreakText) {
+      EpdFontStyle fontStyle = REGULAR;
+      if (self->boldUntilDepth < self->depth && self->italicUntilDepth < self->depth) {
+        fontStyle = BOLD_ITALIC;
+      } else if (self->boldUntilDepth < self->depth) {
+        fontStyle = BOLD;
+      } else if (self->italicUntilDepth < self->depth) {
+        fontStyle = ITALIC;
+      }
+
       self->partWordBuffer[self->partWordBufferIndex] = '\0';
-      self->currentTextBlock->addWord(replaceHtmlEntities(self->partWordBuffer), self->boldUntilDepth < self->depth,
+      self->currentTextBlock->addWord(std::move(replaceHtmlEntities(self->partWordBuffer)), fontStyle);
-                                      self->italicUntilDepth < self->depth);
       self->partWordBufferIndex = 0;
     }
   }
@@ -183,14 +203,14 @@ void XMLCALL EpubHtmlParserSlim::endElement(void* userData, const XML_Char* name
   }
 }
 
-bool EpubHtmlParserSlim::parseAndBuildPages() {
+bool ChapterHtmlSlimParser::parseAndBuildPages() {
-  startNewTextBlock(JUSTIFIED);
+  startNewTextBlock(TextBlock::JUSTIFIED);
 
   const XML_Parser parser = XML_ParserCreate(nullptr);
   int done;
 
   if (!parser) {
-    Serial.println("Couldn't allocate memory for parser");
+    Serial.printf("[%lu] [EHP] Couldn't allocate memory for parser\n", millis());
     return false;
   }
 
@@ -200,7 +220,7 @@ bool EpubHtmlParserSlim::parseAndBuildPages() {
 
   FILE* file = fopen(filepath, "r");
   if (!file) {
-    Serial.printf("Couldn't open file %s\n", filepath);
+    Serial.printf("[%lu] [EHP] Couldn't open file %s\n", millis(), filepath);
     XML_ParserFree(parser);
     return false;
   }
@@ -208,7 +228,7 @@ bool EpubHtmlParserSlim::parseAndBuildPages() {
   do {
     void* const buf = XML_GetBuffer(parser, 1024);
     if (!buf) {
-      Serial.println("Couldn't allocate memory for buffer");
+      Serial.printf("[%lu] [EHP] Couldn't allocate memory for buffer\n", millis());
       XML_ParserFree(parser);
       fclose(file);
       return false;
@@ -217,7 +237,7 @@ bool EpubHtmlParserSlim::parseAndBuildPages() {
     const size_t len = fread(buf, 1, 1024, file);
 
     if (ferror(file)) {
-      Serial.println("Read error");
+      Serial.printf("[%lu] [EHP] File read error\n", millis());
       XML_ParserFree(parser);
       fclose(file);
       return false;
@@ -226,7 +246,7 @@ bool EpubHtmlParserSlim::parseAndBuildPages() {
     done = feof(file);
 
     if (XML_ParseBuffer(parser, static_cast<int>(len), done) == XML_STATUS_ERROR) {
-      Serial.printf("Parse error at line %lu:\n%s\n", XML_GetCurrentLineNumber(parser),
+      Serial.printf("[%lu] [EHP] Parse error at line %lu:\n%s\n", millis(), XML_GetCurrentLineNumber(parser),
                     XML_ErrorString(XML_GetErrorCode(parser)));
       XML_ParserFree(parser);
       fclose(file);
@@ -240,54 +260,45 @@ bool EpubHtmlParserSlim::parseAndBuildPages() {
   // Process last page if there is still text
   if (currentTextBlock) {
     makePages();
-    completePageFn(currentPage);
+    completePageFn(std::move(currentPage));
-    currentPage = nullptr;
+    currentPage.reset();
-    delete currentTextBlock;
+    currentTextBlock.reset();
-    currentTextBlock = nullptr;
   }
 
   return true;
 }
 
-void EpubHtmlParserSlim::makePages() {
+void ChapterHtmlSlimParser::addLineToPage(std::shared_ptr<TextBlock> line) {
+  const int lineHeight = renderer.getLineHeight(fontId) * lineCompression;
+  const int pageHeight = GfxRenderer::getScreenHeight() - marginTop - marginBottom;
+
+  if (currentPageNextY + lineHeight > pageHeight) {
+    completePageFn(std::move(currentPage));
+    currentPage.reset(new Page());
+    currentPageNextY = marginTop;
+  }
+
+  currentPage->elements.push_back(std::make_shared<PageLine>(line, marginLeft, currentPageNextY));
+  currentPageNextY += lineHeight;
+}
+
+void ChapterHtmlSlimParser::makePages() {
   if (!currentTextBlock) {
-    Serial.println("!! No text block to make pages for !!");
+    Serial.printf("[%lu] [EHP] !! No text block to make pages for !!\n", millis());
     return;
   }
 
   if (!currentPage) {
-    currentPage = new Page();
+    currentPage.reset(new Page());
+    currentPageNextY = marginTop;
   }
 
-  const int lineHeight = renderer.getLineHeight();
+  const int lineHeight = renderer.getLineHeight(fontId) * lineCompression;
-  const int pageHeight = renderer.getPageHeight();
+  currentTextBlock->layoutAndExtractLines(
-
+      renderer, fontId, marginLeft + marginRight,
-  // Long running task, make sure to let other things happen
+      [this](const std::shared_ptr<TextBlock>& textBlock) { addLineToPage(textBlock); });
-  vTaskDelay(1);
+  // Extra paragraph spacing if enabled
-
+  if (extraParagraphSpacing) {
-  if (currentTextBlock->getType() == TEXT_BLOCK) {
+    currentPageNextY += lineHeight / 2;
-    const auto lines = currentTextBlock->splitIntoLines(renderer);
-
-    for (const auto line : lines) {
-      if (currentPage->nextY + lineHeight > pageHeight) {
-        completePageFn(currentPage);
-        currentPage = new Page();
-      }
-
-      currentPage->elements.push_back(new PageLine(line, currentPage->nextY));
-      currentPage->nextY += lineHeight;
-    }
-    // add some extra line between blocks
-    currentPage->nextY += lineHeight / 2;
   }
-  // TODO: Image block support
-  // if (block->getType() == BlockType::IMAGE_BLOCK) {
-  //   ImageBlock *imageBlock = (ImageBlock *)block;
-  //   if (y + imageBlock->height > page_height) {
-  //     pages.push_back(new Page());
-  //     y = 0;
-  //   }
-  //   pages.back()->elements.push_back(new PageImage(imageBlock, y));
-  //   y += imageBlock->height;
-  // }
 }

lib/Epub/Epub/parsers/ChapterHtmlSlimParser.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <expat.h>
+
+#include <climits>
+#include <functional>
+#include <memory>
+
+#include "../ParsedText.h"
+#include "../blocks/TextBlock.h"
+
+class Page;
+class GfxRenderer;
+
+#define MAX_WORD_SIZE 200
+
+class ChapterHtmlSlimParser {
+  const char* filepath;
+  GfxRenderer& renderer;
+  std::function<void(std::unique_ptr<Page>)> completePageFn;
+  int depth = 0;
+  int skipUntilDepth = INT_MAX;
+  int boldUntilDepth = INT_MAX;
+  int italicUntilDepth = INT_MAX;
+  // buffer for building up words from characters, will auto break if longer than this
+  // leave one char at end for null pointer
+  char partWordBuffer[MAX_WORD_SIZE + 1] = {};
+  int partWordBufferIndex = 0;
+  std::unique_ptr<ParsedText> currentTextBlock = nullptr;
+  std::unique_ptr<Page> currentPage = nullptr;
+  int16_t currentPageNextY = 0;
+  int fontId;
+  float lineCompression;
+  int marginTop;
+  int marginRight;
+  int marginBottom;
+  int marginLeft;
+  bool extraParagraphSpacing;
+
+  void startNewTextBlock(TextBlock::BLOCK_STYLE style);
+  void makePages();
+  // XML callbacks
+  static void XMLCALL startElement(void* userData, const XML_Char* name, const XML_Char** atts);
+  static void XMLCALL characterData(void* userData, const XML_Char* s, int len);
+  static void XMLCALL endElement(void* userData, const XML_Char* name);
+
+ public:
+  explicit ChapterHtmlSlimParser(const char* filepath, GfxRenderer& renderer, const int fontId,
+                                 const float lineCompression, const int marginTop, const int marginRight,
+                                 const int marginBottom, const int marginLeft, const bool extraParagraphSpacing,
+                                 const std::function<void(std::unique_ptr<Page>)>& completePageFn)
+      : filepath(filepath),
+        renderer(renderer),
+        fontId(fontId),
+        lineCompression(lineCompression),
+        marginTop(marginTop),
+        marginRight(marginRight),
+        marginBottom(marginBottom),
+        marginLeft(marginLeft),
+        extraParagraphSpacing(extraParagraphSpacing),
+        completePageFn(completePageFn) {}
+  ~ChapterHtmlSlimParser() = default;
+  bool parseAndBuildPages();
+  void addLineToPage(std::shared_ptr<TextBlock> line);
+};

lib/Epub/Epub/parsers/ContainerParser.cpp

@@ -0,0 +1,95 @@
+#include "ContainerParser.h"
+
+#include <HardwareSerial.h>
+
+bool ContainerParser::setup() {
+  parser = XML_ParserCreate(nullptr);
+  if (!parser) {
+    Serial.printf("[%lu] [CTR] Couldn't allocate memory for parser\n", millis());
+    return false;
+  }
+
+  XML_SetUserData(parser, this);
+  XML_SetElementHandler(parser, startElement, endElement);
+  return true;
+}
+
+ContainerParser::~ContainerParser() {
+  if (parser) {
+    XML_ParserFree(parser);
+    parser = nullptr;
+  }
+}
+
+size_t ContainerParser::write(const uint8_t data) { return write(&data, 1); }
+
+size_t ContainerParser::write(const uint8_t* buffer, const size_t size) {
+  if (!parser) return 0;
+
+  const uint8_t* currentBufferPos = buffer;
+  auto remainingInBuffer = size;
+
+  while (remainingInBuffer > 0) {
+    void* const buf = XML_GetBuffer(parser, 1024);
+    if (!buf) {
+      Serial.printf("[%lu] [CTR] Couldn't allocate buffer\n", millis());
+      return 0;
+    }
+
+    const auto toRead = remainingInBuffer < 1024 ? remainingInBuffer : 1024;
+    memcpy(buf, currentBufferPos, toRead);
+
+    if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
+      Serial.printf("[%lu] [CTR] Parse error: %s\n", millis(), XML_ErrorString(XML_GetErrorCode(parser)));
+      return 0;
+    }
+
+    currentBufferPos += toRead;
+    remainingInBuffer -= toRead;
+    remainingSize -= toRead;
+  }
+  return size;
+}
+
+void XMLCALL ContainerParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
+  auto* self = static_cast<ContainerParser*>(userData);
+
+  // Simple state tracking to ensure we are looking at the valid schema structure
+  if (self->state == START && strcmp(name, "container") == 0) {
+    self->state = IN_CONTAINER;
+    return;
+  }
+
+  if (self->state == IN_CONTAINER && strcmp(name, "rootfiles") == 0) {
+    self->state = IN_ROOTFILES;
+    return;
+  }
+
+  if (self->state == IN_ROOTFILES && strcmp(name, "rootfile") == 0) {
+    const char* mediaType = nullptr;
+    const char* path = nullptr;
+
+    for (int i = 0; atts[i]; i += 2) {
+      if (strcmp(atts[i], "media-type") == 0) {
+        mediaType = atts[i + 1];
+      } else if (strcmp(atts[i], "full-path") == 0) {
+        path = atts[i + 1];
+      }
+    }
+
+    // Check if this is the standard OEBPS package
+    if (mediaType && path && strcmp(mediaType, "application/oebps-package+xml") == 0) {
+      self->fullPath = path;
+    }
+  }
+}
+
+void XMLCALL ContainerParser::endElement(void* userData, const XML_Char* name) {
+  auto* self = static_cast<ContainerParser*>(userData);
+
+  if (self->state == IN_ROOTFILES && strcmp(name, "rootfiles") == 0) {
+    self->state = IN_CONTAINER;
+  } else if (self->state == IN_CONTAINER && strcmp(name, "container") == 0) {
+    self->state = START;
+  }
+}

lib/Epub/Epub/parsers/ContainerParser.h

@@ -0,0 +1,32 @@
+#pragma once
+#include <Print.h>
+
+#include <string>
+
+#include "expat.h"
+
+class ContainerParser final : public Print {
+  enum ParserState {
+    START,
+    IN_CONTAINER,
+    IN_ROOTFILES,
+  };
+
+  size_t remainingSize;
+  XML_Parser parser = nullptr;
+  ParserState state = START;
+
+  static void startElement(void* userData, const XML_Char* name, const XML_Char** atts);
+  static void endElement(void* userData, const XML_Char* name);
+
+ public:
+  std::string fullPath;
+
+  explicit ContainerParser(const size_t xmlSize) : remainingSize(xmlSize) {}
+  ~ContainerParser() override;
+
+  bool setup();
+
+  size_t write(uint8_t) override;
+  size_t write(const uint8_t* buffer, size_t size) override;
+};

lib/Epub/Epub/parsers/ContentOpfParser.cpp

@@ -0,0 +1,190 @@
+#include "ContentOpfParser.h"
+
+#include <HardwareSerial.h>
+#include <ZipFile.h>
+
+namespace {
+constexpr char MEDIA_TYPE_NCX[] = "application/x-dtbncx+xml";
+}
+
+bool ContentOpfParser::setup() {
+  parser = XML_ParserCreate(nullptr);
+  if (!parser) {
+    Serial.printf("[%lu] [COF] Couldn't allocate memory for parser\n", millis());
+    return false;
+  }
+
+  XML_SetUserData(parser, this);
+  XML_SetElementHandler(parser, startElement, endElement);
+  XML_SetCharacterDataHandler(parser, characterData);
+  return true;
+}
+
+ContentOpfParser::~ContentOpfParser() {
+  if (parser) {
+    XML_ParserFree(parser);
+    parser = nullptr;
+  }
+}
+
+size_t ContentOpfParser::write(const uint8_t data) { return write(&data, 1); }
+
+size_t ContentOpfParser::write(const uint8_t* buffer, const size_t size) {
+  if (!parser) return 0;
+
+  const uint8_t* currentBufferPos = buffer;
+  auto remainingInBuffer = size;
+
+  while (remainingInBuffer > 0) {
+    void* const buf = XML_GetBuffer(parser, 1024);
+
+    if (!buf) {
+      Serial.printf("[%lu] [COF] Couldn't allocate memory for buffer\n", millis());
+      XML_ParserFree(parser);
+      parser = nullptr;
+      return 0;
+    }
+
+    const auto toRead = remainingInBuffer < 1024 ? remainingInBuffer : 1024;
+    memcpy(buf, currentBufferPos, toRead);
+
+    if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
+      Serial.printf("[%lu] [COF] Parse error at line %lu: %s\n", millis(), XML_GetCurrentLineNumber(parser),
+                    XML_ErrorString(XML_GetErrorCode(parser)));
+      XML_ParserFree(parser);
+      parser = nullptr;
+      return 0;
+    }
+
+    currentBufferPos += toRead;
+    remainingInBuffer -= toRead;
+    remainingSize -= toRead;
+  }
+
+  return size;
+}
+
+void XMLCALL ContentOpfParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
+  auto* self = static_cast<ContentOpfParser*>(userData);
+  (void)atts;
+
+  if (self->state == START && (strcmp(name, "package") == 0 || strcmp(name, "opf:package") == 0)) {
+    self->state = IN_PACKAGE;
+    return;
+  }
+
+  if (self->state == IN_PACKAGE && (strcmp(name, "metadata") == 0 || strcmp(name, "opf:metadata") == 0)) {
+    self->state = IN_METADATA;
+    return;
+  }
+
+  if (self->state == IN_METADATA && strcmp(name, "dc:title") == 0) {
+    self->state = IN_BOOK_TITLE;
+    return;
+  }
+
+  if (self->state == IN_PACKAGE && (strcmp(name, "manifest") == 0 || strcmp(name, "opf:manifest") == 0)) {
+    self->state = IN_MANIFEST;
+    return;
+  }
+
+  if (self->state == IN_PACKAGE && (strcmp(name, "spine") == 0 || strcmp(name, "opf:spine") == 0)) {
+    self->state = IN_SPINE;
+    return;
+  }
+
+  if (self->state == IN_METADATA && (strcmp(name, "meta") == 0 || strcmp(name, "opf:meta") == 0)) {
+    bool isCover = false;
+    std::string coverItemId;
+
+    for (int i = 0; atts[i]; i += 2) {
+      if (strcmp(atts[i], "name") == 0 && strcmp(atts[i + 1], "cover") == 0) {
+        isCover = true;
+      } else if (strcmp(atts[i], "content") == 0) {
+        coverItemId = atts[i + 1];
+      }
+    }
+
+    if (isCover) {
+      self->coverItemId = coverItemId;
+    }
+    return;
+  }
+
+  if (self->state == IN_MANIFEST && (strcmp(name, "item") == 0 || strcmp(name, "opf:item") == 0)) {
+    std::string itemId;
+    std::string href;
+    std::string mediaType;
+
+    for (int i = 0; atts[i]; i += 2) {
+      if (strcmp(atts[i], "id") == 0) {
+        itemId = atts[i + 1];
+      } else if (strcmp(atts[i], "href") == 0) {
+        href = self->baseContentPath + atts[i + 1];
+      } else if (strcmp(atts[i], "media-type") == 0) {
+        mediaType = atts[i + 1];
+      }
+    }
+
+    self->items[itemId] = href;
+
+    if (mediaType == MEDIA_TYPE_NCX) {
+      if (self->tocNcxPath.empty()) {
+        self->tocNcxPath = href;
+      } else {
+        Serial.printf("[%lu] [COF] Warning: Multiple NCX files found in manifest. Ignoring duplicate: %s\n", millis(),
+                      href.c_str());
+      }
+    }
+    return;
+  }
+
+  if (self->state == IN_SPINE && (strcmp(name, "itemref") == 0 || strcmp(name, "opf:itemref") == 0)) {
+    for (int i = 0; atts[i]; i += 2) {
+      if (strcmp(atts[i], "idref") == 0) {
+        self->spineRefs.emplace_back(atts[i + 1]);
+        break;
+      }
+    }
+    return;
+  }
+}
+
+void XMLCALL ContentOpfParser::characterData(void* userData, const XML_Char* s, const int len) {
+  auto* self = static_cast<ContentOpfParser*>(userData);
+
+  if (self->state == IN_BOOK_TITLE) {
+    self->title.append(s, len);
+    return;
+  }
+}
+
+void XMLCALL ContentOpfParser::endElement(void* userData, const XML_Char* name) {
+  auto* self = static_cast<ContentOpfParser*>(userData);
+  (void)name;
+
+  if (self->state == IN_SPINE && (strcmp(name, "spine") == 0 || strcmp(name, "opf:spine") == 0)) {
+    self->state = IN_PACKAGE;
+    return;
+  }
+
+  if (self->state == IN_MANIFEST && (strcmp(name, "manifest") == 0 || strcmp(name, "opf:manifest") == 0)) {
+    self->state = IN_PACKAGE;
+    return;
+  }
+
+  if (self->state == IN_BOOK_TITLE && strcmp(name, "dc:title") == 0) {
+    self->state = IN_METADATA;
+    return;
+  }
+
+  if (self->state == IN_METADATA && (strcmp(name, "metadata") == 0 || strcmp(name, "opf:metadata") == 0)) {
+    self->state = IN_PACKAGE;
+    return;
+  }
+
+  if (self->state == IN_PACKAGE && (strcmp(name, "package") == 0 || strcmp(name, "opf:package") == 0)) {
+    self->state = START;
+    return;
+  }
+}

lib/Epub/Epub/parsers/ContentOpfParser.h

@@ -0,0 +1,43 @@
+#pragma once
+#include <Print.h>
+
+#include <map>
+
+#include "Epub.h"
+#include "expat.h"
+
+class ContentOpfParser final : public Print {
+  enum ParserState {
+    START,
+    IN_PACKAGE,
+    IN_METADATA,
+    IN_BOOK_TITLE,
+    IN_MANIFEST,
+    IN_SPINE,
+  };
+
+  const std::string& baseContentPath;
+  size_t remainingSize;
+  XML_Parser parser = nullptr;
+  ParserState state = START;
+
+  static void startElement(void* userData, const XML_Char* name, const XML_Char** atts);
+  static void characterData(void* userData, const XML_Char* s, int len);
+  static void endElement(void* userData, const XML_Char* name);
+
+ public:
+  std::string title;
+  std::string tocNcxPath;
+  std::string coverItemId;
+  std::map<std::string, std::string> items;
+  std::vector<std::string> spineRefs;
+
+  explicit ContentOpfParser(const std::string& baseContentPath, const size_t xmlSize)
+      : baseContentPath(baseContentPath), remainingSize(xmlSize) {}
+  ~ContentOpfParser() override;
+
+  bool setup();
+
+  size_t write(uint8_t) override;
+  size_t write(const uint8_t* buffer, size_t size) override;
+};

lib/Epub/Epub/parsers/TocNcxParser.cpp

@@ -0,0 +1,165 @@
+#include "TocNcxParser.h"
+
+#include <Esp.h>
+#include <HardwareSerial.h>
+
+bool TocNcxParser::setup() {
+  parser = XML_ParserCreate(nullptr);
+  if (!parser) {
+    Serial.printf("[%lu] [TOC] Couldn't allocate memory for parser\n", millis());
+    return false;
+  }
+
+  XML_SetUserData(parser, this);
+  XML_SetElementHandler(parser, startElement, endElement);
+  XML_SetCharacterDataHandler(parser, characterData);
+  return true;
+}
+
+TocNcxParser::~TocNcxParser() {
+  if (parser) {
+    XML_ParserFree(parser);
+    parser = nullptr;
+  }
+}
+
+size_t TocNcxParser::write(const uint8_t data) { return write(&data, 1); }
+
+size_t TocNcxParser::write(const uint8_t* buffer, const size_t size) {
+  if (!parser) return 0;
+
+  const uint8_t* currentBufferPos = buffer;
+  auto remainingInBuffer = size;
+
+  while (remainingInBuffer > 0) {
+    void* const buf = XML_GetBuffer(parser, 1024);
+    if (!buf) {
+      Serial.printf("[%lu] [TOC] Couldn't allocate memory for buffer\n", millis());
+      return 0;
+    }
+
+    const auto toRead = remainingInBuffer < 1024 ? remainingInBuffer : 1024;
+    memcpy(buf, currentBufferPos, toRead);
+
+    if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
+      Serial.printf("[%lu] [TOC] Parse error at line %lu: %s\n", millis(), XML_GetCurrentLineNumber(parser),
+                    XML_ErrorString(XML_GetErrorCode(parser)));
+      return 0;
+    }
+
+    currentBufferPos += toRead;
+    remainingInBuffer -= toRead;
+    remainingSize -= toRead;
+  }
+  return size;
+}
+
+void XMLCALL TocNcxParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
+  // NOTE: We rely on navPoint label and content coming before any nested navPoints, this will be fine:
+  // <navPoint>
+  //   <navLabel><text>Chapter 1</text></navLabel>
+  //   <content src="ch1.html"/>
+  //   <navPoint> ...nested... </navPoint>
+  // </navPoint>
+  //
+  // This will NOT:
+  // <navPoint>
+  //   <navPoint> ...nested... </navPoint>
+  //   <navLabel><text>Chapter 1</text></navLabel>
+  //   <content src="ch1.html"/>
+  // </navPoint>
+
+  auto* self = static_cast<TocNcxParser*>(userData);
+
+  if (self->state == START && strcmp(name, "ncx") == 0) {
+    self->state = IN_NCX;
+    return;
+  }
+
+  if (self->state == IN_NCX && strcmp(name, "navMap") == 0) {
+    self->state = IN_NAV_MAP;
+    return;
+  }
+
+  // Handles both top-level and nested navPoints
+  if ((self->state == IN_NAV_MAP || self->state == IN_NAV_POINT) && strcmp(name, "navPoint") == 0) {
+    self->state = IN_NAV_POINT;
+    self->currentDepth++;
+
+    self->currentLabel.clear();
+    self->currentSrc.clear();
+    return;
+  }
+
+  if (self->state == IN_NAV_POINT && strcmp(name, "navLabel") == 0) {
+    self->state = IN_NAV_LABEL;
+    return;
+  }
+
+  if (self->state == IN_NAV_LABEL && strcmp(name, "text") == 0) {
+    self->state = IN_NAV_LABEL_TEXT;
+    return;
+  }
+
+  if (self->state == IN_NAV_POINT && strcmp(name, "content") == 0) {
+    for (int i = 0; atts[i]; i += 2) {
+      if (strcmp(atts[i], "src") == 0) {
+        self->currentSrc = atts[i + 1];
+        break;
+      }
+    }
+    return;
+  }
+}
+
+void XMLCALL TocNcxParser::characterData(void* userData, const XML_Char* s, const int len) {
+  auto* self = static_cast<TocNcxParser*>(userData);
+  if (self->state == IN_NAV_LABEL_TEXT) {
+    self->currentLabel.append(s, len);
+  }
+}
+
+void XMLCALL TocNcxParser::endElement(void* userData, const XML_Char* name) {
+  auto* self = static_cast<TocNcxParser*>(userData);
+
+  if (self->state == IN_NAV_LABEL_TEXT && strcmp(name, "text") == 0) {
+    self->state = IN_NAV_LABEL;
+    return;
+  }
+
+  if (self->state == IN_NAV_LABEL && strcmp(name, "navLabel") == 0) {
+    self->state = IN_NAV_POINT;
+    return;
+  }
+
+  if (self->state == IN_NAV_POINT && strcmp(name, "navPoint") == 0) {
+    self->currentDepth--;
+    if (self->currentDepth == 0) {
+      self->state = IN_NAV_MAP;
+    }
+    return;
+  }
+
+  if (self->state == IN_NAV_POINT && strcmp(name, "content") == 0) {
+    // At this point (end of content tag), we likely have both Label (from previous tags) and Src.
+    // This is the safest place to push the data, assuming <navLabel> always comes before <content>.
+    // NCX spec says navLabel comes before content.
+    if (!self->currentLabel.empty() && !self->currentSrc.empty()) {
+      std::string href = self->baseContentPath + self->currentSrc;
+      std::string anchor;
+
+      const size_t pos = href.find('#');
+      if (pos != std::string::npos) {
+        anchor = href.substr(pos + 1);
+        href = href.substr(0, pos);
+      }
+
+      // Push to vector
+      self->toc.push_back({std::move(self->currentLabel), std::move(href), std::move(anchor), self->currentDepth});
+
+      // Clear them so we don't re-add them if there are weird XML structures
+      self->currentLabel.clear();
+      self->currentSrc.clear();
+    }
+  }
+}

lib/Epub/Epub/parsers/TocNcxParser.h

@@ -0,0 +1,37 @@
+#pragma once
+#include <Print.h>
+
+#include <string>
+#include <vector>
+
+#include "Epub/EpubTocEntry.h"
+#include "expat.h"
+
+class TocNcxParser final : public Print {
+  enum ParserState { START, IN_NCX, IN_NAV_MAP, IN_NAV_POINT, IN_NAV_LABEL, IN_NAV_LABEL_TEXT, IN_CONTENT };
+
+  const std::string& baseContentPath;
+  size_t remainingSize;
+  XML_Parser parser = nullptr;
+  ParserState state = START;
+
+  std::string currentLabel;
+  std::string currentSrc;
+  uint8_t currentDepth = 0;
+
+  static void startElement(void* userData, const XML_Char* name, const XML_Char** atts);
+  static void characterData(void* userData, const XML_Char* s, int len);
+  static void endElement(void* userData, const XML_Char* name);
+
+ public:
+  std::vector<EpubTocEntry> toc;
+
+  explicit TocNcxParser(const std::string& baseContentPath, const size_t xmlSize)
+      : baseContentPath(baseContentPath), remainingSize(xmlSize) {}
+  ~TocNcxParser() override;
+
+  bool setup();
+
+  size_t write(uint8_t) override;
+  size_t write(const uint8_t* buffer, size_t size) override;
+};

lib/GfxRenderer/Bitmap.cpp

@@ -0,0 +1,200 @@
+#include "Bitmap.h"
+
+#include <cstdlib>
+#include <cstring>
+
+uint16_t Bitmap::readLE16(File& f) {
+  const int c0 = f.read();
+  const int c1 = f.read();
+  const auto b0 = static_cast<uint8_t>(c0 < 0 ? 0 : c0);
+  const auto b1 = static_cast<uint8_t>(c1 < 0 ? 0 : c1);
+  return static_cast<uint16_t>(b0) | (static_cast<uint16_t>(b1) << 8);
+}
+
+uint32_t Bitmap::readLE32(File& f) {
+  const int c0 = f.read();
+  const int c1 = f.read();
+  const int c2 = f.read();
+  const int c3 = f.read();
+
+  const auto b0 = static_cast<uint8_t>(c0 < 0 ? 0 : c0);
+  const auto b1 = static_cast<uint8_t>(c1 < 0 ? 0 : c1);
+  const auto b2 = static_cast<uint8_t>(c2 < 0 ? 0 : c2);
+  const auto b3 = static_cast<uint8_t>(c3 < 0 ? 0 : c3);
+
+  return static_cast<uint32_t>(b0) | (static_cast<uint32_t>(b1) << 8) | (static_cast<uint32_t>(b2) << 16) |
+         (static_cast<uint32_t>(b3) << 24);
+}
+
+const char* Bitmap::errorToString(BmpReaderError err) {
+  switch (err) {
+    case BmpReaderError::Ok:
+      return "Ok";
+    case BmpReaderError::FileInvalid:
+      return "FileInvalid";
+    case BmpReaderError::SeekStartFailed:
+      return "SeekStartFailed";
+    case BmpReaderError::NotBMP:
+      return "NotBMP (missing 'BM')";
+    case BmpReaderError::DIBTooSmall:
+      return "DIBTooSmall (<40 bytes)";
+    case BmpReaderError::BadPlanes:
+      return "BadPlanes (!= 1)";
+    case BmpReaderError::UnsupportedBpp:
+      return "UnsupportedBpp (expected 1, 2, 8, 24, or 32)";
+    case BmpReaderError::UnsupportedCompression:
+      return "UnsupportedCompression (expected BI_RGB or BI_BITFIELDS for 32bpp)";
+    case BmpReaderError::BadDimensions:
+      return "BadDimensions";
+    case BmpReaderError::PaletteTooLarge:
+      return "PaletteTooLarge";
+
+    case BmpReaderError::SeekPixelDataFailed:
+      return "SeekPixelDataFailed";
+    case BmpReaderError::BufferTooSmall:
+      return "BufferTooSmall";
+
+    case BmpReaderError::OomRowBuffer:
+      return "OomRowBuffer";
+    case BmpReaderError::ShortReadRow:
+      return "ShortReadRow";
+  }
+  return "Unknown";
+}
+
+BmpReaderError Bitmap::parseHeaders() {
+  if (!file) return BmpReaderError::FileInvalid;
+  if (!file.seek(0)) return BmpReaderError::SeekStartFailed;
+
+  // --- BMP FILE HEADER ---
+  const uint16_t bfType = readLE16(file);
+  if (bfType != 0x4D42) return BmpReaderError::NotBMP;
+
+  file.seek(8, SeekCur);
+  bfOffBits = readLE32(file);
+
+  // --- DIB HEADER ---
+  const uint32_t biSize = readLE32(file);
+  if (biSize < 40) return BmpReaderError::DIBTooSmall;
+
+  width = static_cast<int32_t>(readLE32(file));
+  const auto rawHeight = static_cast<int32_t>(readLE32(file));
+  topDown = rawHeight < 0;
+  height = topDown ? -rawHeight : rawHeight;
+
+  const uint16_t planes = readLE16(file);
+  bpp = readLE16(file);
+  const uint32_t comp = readLE32(file);
+  const bool validBpp = bpp == 1 || bpp == 2 || bpp == 8 || bpp == 24 || bpp == 32;
+
+  if (planes != 1) return BmpReaderError::BadPlanes;
+  if (!validBpp) return BmpReaderError::UnsupportedBpp;
+  // Allow BI_RGB (0) for all, and BI_BITFIELDS (3) for 32bpp which is common for BGRA masks.
+  if (!(comp == 0 || (bpp == 32 && comp == 3))) return BmpReaderError::UnsupportedCompression;
+
+  file.seek(12, SeekCur);  // biSizeImage, biXPelsPerMeter, biYPelsPerMeter
+  const uint32_t colorsUsed = readLE32(file);
+  if (colorsUsed > 256u) return BmpReaderError::PaletteTooLarge;
+  file.seek(4, SeekCur);  // biClrImportant
+
+  if (width <= 0 || height <= 0) return BmpReaderError::BadDimensions;
+
+  // Pre-calculate Row Bytes to avoid doing this every row
+  rowBytes = (width * bpp + 31) / 32 * 4;
+
+  for (int i = 0; i < 256; i++) paletteLum[i] = static_cast<uint8_t>(i);
+  if (colorsUsed > 0) {
+    for (uint32_t i = 0; i < colorsUsed; i++) {
+      uint8_t rgb[4];
+      file.read(rgb, 4);  // Read B, G, R, Reserved in one go
+      paletteLum[i] = (77u * rgb[2] + 150u * rgb[1] + 29u * rgb[0]) >> 8;
+    }
+  }
+
+  if (!file.seek(bfOffBits)) {
+    return BmpReaderError::SeekPixelDataFailed;
+  }
+
+  return BmpReaderError::Ok;
+}
+
+// packed 2bpp output, 0 = black, 1 = dark gray, 2 = light gray, 3 = white
+BmpReaderError Bitmap::readRow(uint8_t* data, uint8_t* rowBuffer) const {
+  // Note: rowBuffer should be pre-allocated by the caller to size 'rowBytes'
+  if (file.read(rowBuffer, rowBytes) != rowBytes) return BmpReaderError::ShortReadRow;
+
+  uint8_t* outPtr = data;
+  uint8_t currentOutByte = 0;
+  int bitShift = 6;
+
+  // Helper lambda to pack 2bpp color into the output stream
+  auto packPixel = [&](const uint8_t lum) {
+    uint8_t color = (lum >> 6);  // Simple 2-bit reduction: 0-255 -> 0-3
+    currentOutByte |= (color << bitShift);
+    if (bitShift == 0) {
+      *outPtr++ = currentOutByte;
+      currentOutByte = 0;
+      bitShift = 6;
+    } else {
+      bitShift -= 2;
+    }
+  };
+
+  uint8_t lum;
+
+  switch (bpp) {
+    case 32: {
+      const uint8_t* p = rowBuffer;
+      for (int x = 0; x < width; x++) {
+        lum = (77u * p[2] + 150u * p[1] + 29u * p[0]) >> 8;
+        packPixel(lum);
+        p += 4;
+      }
+      break;
+    }
+    case 24: {
+      const uint8_t* p = rowBuffer;
+      for (int x = 0; x < width; x++) {
+        lum = (77u * p[2] + 150u * p[1] + 29u * p[0]) >> 8;
+        packPixel(lum);
+        p += 3;
+      }
+      break;
+    }
+    case 8: {
+      for (int x = 0; x < width; x++) {
+        packPixel(paletteLum[rowBuffer[x]]);
+      }
+      break;
+    }
+    case 2: {
+      for (int x = 0; x < width; x++) {
+        lum = paletteLum[(rowBuffer[x >> 2] >> (6 - ((x & 3) * 2))) & 0x03];
+        packPixel(lum);
+      }
+      break;
+    }
+    case 1: {
+      for (int x = 0; x < width; x++) {
+        lum = (rowBuffer[x >> 3] & (0x80 >> (x & 7))) ? 0xFF : 0x00;
+        packPixel(lum);
+      }
+      break;
+    }
+    default:
+      return BmpReaderError::UnsupportedBpp;
+  }
+
+  // Flush remaining bits if width is not a multiple of 4
+  if (bitShift != 6) *outPtr = currentOutByte;
+
+  return BmpReaderError::Ok;
+}
+
+BmpReaderError Bitmap::rewindToData() const {
+  if (!file.seek(bfOffBits)) {
+    return BmpReaderError::SeekPixelDataFailed;
+  }
+
+  return BmpReaderError::Ok;
+}

lib/GfxRenderer/Bitmap.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <FS.h>
+
+enum class BmpReaderError : uint8_t {
+  Ok = 0,
+  FileInvalid,
+  SeekStartFailed,
+
+  NotBMP,
+  DIBTooSmall,
+
+  BadPlanes,
+  UnsupportedBpp,
+  UnsupportedCompression,
+
+  BadDimensions,
+  PaletteTooLarge,
+
+  SeekPixelDataFailed,
+  BufferTooSmall,
+  OomRowBuffer,
+  ShortReadRow,
+};
+
+class Bitmap {
+ public:
+  static const char* errorToString(BmpReaderError err);
+
+  explicit Bitmap(File& file) : file(file) {}
+  BmpReaderError parseHeaders();
+  BmpReaderError readRow(uint8_t* data, uint8_t* rowBuffer) const;
+  BmpReaderError rewindToData() const;
+  int getWidth() const { return width; }
+  int getHeight() const { return height; }
+  bool isTopDown() const { return topDown; }
+  bool hasGreyscale() const { return bpp > 1; }
+  int getRowBytes() const { return rowBytes; }
+
+ private:
+  static uint16_t readLE16(File& f);
+  static uint32_t readLE32(File& f);
+
+  File& file;
+  int width = 0;
+  int height = 0;
+  bool topDown = false;
+  uint32_t bfOffBits = 0;
+  uint16_t bpp = 0;
+  int rowBytes = 0;
+  uint8_t paletteLum[256] = {};
+};

lib/GfxRenderer/GfxRenderer.cpp

@@ -0,0 +1,410 @@
+#include "GfxRenderer.h"
+
+#include <Utf8.h>
+
+void GfxRenderer::insertFont(const int fontId, EpdFontFamily font) { fontMap.insert({fontId, font}); }
+
+void GfxRenderer::drawPixel(const int x, const int y, const bool state) const {
+  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
+
+  // Early return if no framebuffer is set
+  if (!frameBuffer) {
+    Serial.printf("[%lu] [GFX] !! No framebuffer\n", millis());
+    return;
+  }
+
+  // Rotate coordinates: portrait (480x800) -> landscape (800x480)
+  // Rotation: 90 degrees clockwise
+  const int rotatedX = y;
+  const int rotatedY = EInkDisplay::DISPLAY_HEIGHT - 1 - x;
+
+  // Bounds checking (portrait: 480x800)
+  if (rotatedX < 0 || rotatedX >= EInkDisplay::DISPLAY_WIDTH || rotatedY < 0 ||
+      rotatedY >= EInkDisplay::DISPLAY_HEIGHT) {
+    Serial.printf("[%lu] [GFX] !! Outside range (%d, %d)\n", millis(), x, y);
+    return;
+  }
+
+  // Calculate byte position and bit position
+  const uint16_t byteIndex = rotatedY * EInkDisplay::DISPLAY_WIDTH_BYTES + (rotatedX / 8);
+  const uint8_t bitPosition = 7 - (rotatedX % 8);  // MSB first
+
+  if (state) {
+    frameBuffer[byteIndex] &= ~(1 << bitPosition);  // Clear bit
+  } else {
+    frameBuffer[byteIndex] |= 1 << bitPosition;  // Set bit
+  }
+}
+
+int GfxRenderer::getTextWidth(const int fontId, const char* text, const EpdFontStyle style) const {
+  if (fontMap.count(fontId) == 0) {
+    Serial.printf("[%lu] [GFX] Font %d not found\n", millis(), fontId);
+    return 0;
+  }
+
+  int w = 0, h = 0;
+  fontMap.at(fontId).getTextDimensions(text, &w, &h, style);
+  return w;
+}
+
+void GfxRenderer::drawCenteredText(const int fontId, const int y, const char* text, const bool black,
+                                   const EpdFontStyle style) const {
+  const int x = (getScreenWidth() - getTextWidth(fontId, text, style)) / 2;
+  drawText(fontId, x, y, text, black, style);
+}
+
+void GfxRenderer::drawText(const int fontId, const int x, const int y, const char* text, const bool black,
+                           const EpdFontStyle style) const {
+  const int yPos = y + getLineHeight(fontId);
+  int xpos = x;
+
+  // cannot draw a NULL / empty string
+  if (text == nullptr || *text == '\0') {
+    return;
+  }
+
+  if (fontMap.count(fontId) == 0) {
+    Serial.printf("[%lu] [GFX] Font %d not found\n", millis(), fontId);
+    return;
+  }
+  const auto font = fontMap.at(fontId);
+
+  // no printable characters
+  if (!font.hasPrintableChars(text, style)) {
+    return;
+  }
+
+  uint32_t cp;
+  while ((cp = utf8NextCodepoint(reinterpret_cast<const uint8_t**>(&text)))) {
+    renderChar(font, cp, &xpos, &yPos, black, style);
+  }
+}
+
+void GfxRenderer::drawLine(int x1, int y1, int x2, int y2, const bool state) const {
+  if (x1 == x2) {
+    if (y2 < y1) {
+      std::swap(y1, y2);
+    }
+    for (int y = y1; y <= y2; y++) {
+      drawPixel(x1, y, state);
+    }
+  } else if (y1 == y2) {
+    if (x2 < x1) {
+      std::swap(x1, x2);
+    }
+    for (int x = x1; x <= x2; x++) {
+      drawPixel(x, y1, state);
+    }
+  } else {
+    // TODO: Implement
+    Serial.printf("[%lu] [GFX] Line drawing not supported\n", millis());
+  }
+}
+
+void GfxRenderer::drawRect(const int x, const int y, const int width, const int height, const bool state) const {
+  drawLine(x, y, x + width - 1, y, state);
+  drawLine(x + width - 1, y, x + width - 1, y + height - 1, state);
+  drawLine(x + width - 1, y + height - 1, x, y + height - 1, state);
+  drawLine(x, y, x, y + height - 1, state);
+}
+
+void GfxRenderer::fillRect(const int x, const int y, const int width, const int height, const bool state) const {
+  for (int fillY = y; fillY < y + height; fillY++) {
+    drawLine(x, fillY, x + width - 1, fillY, state);
+  }
+}
+
+void GfxRenderer::drawImage(const uint8_t bitmap[], const int x, const int y, const int width, const int height) const {
+  // Flip X and Y for portrait mode
+  einkDisplay.drawImage(bitmap, y, x, height, width);
+}
+
+void GfxRenderer::drawBitmap(const Bitmap& bitmap, const int x, const int y, const int maxWidth,
+                             const int maxHeight) const {
+  float scale = 1.0f;
+  bool isScaled = false;
+  if (maxWidth > 0 && bitmap.getWidth() > maxWidth) {
+    scale = static_cast<float>(maxWidth) / static_cast<float>(bitmap.getWidth());
+    isScaled = true;
+  }
+  if (maxHeight > 0 && bitmap.getHeight() > maxHeight) {
+    scale = std::min(scale, static_cast<float>(maxHeight) / static_cast<float>(bitmap.getHeight()));
+    isScaled = true;
+  }
+
+  const uint8_t outputRowSize = (bitmap.getWidth() + 3) / 4;
+  auto* outputRow = static_cast<uint8_t*>(malloc(outputRowSize));
+  auto* rowBytes = static_cast<uint8_t*>(malloc(bitmap.getRowBytes()));
+
+  if (!outputRow || !rowBytes) {
+    Serial.printf("[%lu] [GFX] !! Failed to allocate BMP row buffers\n", millis());
+    free(outputRow);
+    free(rowBytes);
+    return;
+  }
+
+  for (int bmpY = 0; bmpY < bitmap.getHeight(); bmpY++) {
+    // The BMP's (0, 0) is the bottom-left corner (if the height is positive, top-left if negative).
+    // Screen's (0, 0) is the top-left corner.
+    int screenY = y + (bitmap.isTopDown() ? bmpY : bitmap.getHeight() - 1 - bmpY);
+    if (isScaled) {
+      screenY = std::floor(screenY * scale);
+    }
+    if (screenY >= getScreenHeight()) {
+      break;
+    }
+
+    if (bitmap.readRow(outputRow, rowBytes) != BmpReaderError::Ok) {
+      Serial.printf("[%lu] [GFX] Failed to read row %d from bitmap\n", millis(), bmpY);
+      free(outputRow);
+      free(rowBytes);
+      return;
+    }
+
+    for (int bmpX = 0; bmpX < bitmap.getWidth(); bmpX++) {
+      int screenX = x + bmpX;
+      if (isScaled) {
+        screenX = std::floor(screenX * scale);
+      }
+      if (screenX >= getScreenWidth()) {
+        break;
+      }
+
+      const uint8_t val = outputRow[bmpX / 4] >> (6 - ((bmpX * 2) % 8)) & 0x3;
+
+      if (renderMode == BW && val < 3) {
+        drawPixel(screenX, screenY);
+      } else if (renderMode == GRAYSCALE_MSB && (val == 1 || val == 2)) {
+        drawPixel(screenX, screenY, false);
+      } else if (renderMode == GRAYSCALE_LSB && val == 1) {
+        drawPixel(screenX, screenY, false);
+      }
+    }
+  }
+
+  free(outputRow);
+  free(rowBytes);
+}
+
+void GfxRenderer::clearScreen(const uint8_t color) const { einkDisplay.clearScreen(color); }
+
+void GfxRenderer::invertScreen() const {
+  uint8_t* buffer = einkDisplay.getFrameBuffer();
+  if (!buffer) {
+    Serial.printf("[%lu] [GFX] !! No framebuffer in invertScreen\n", millis());
+    return;
+  }
+  for (int i = 0; i < EInkDisplay::BUFFER_SIZE; i++) {
+    buffer[i] = ~buffer[i];
+  }
+}
+
+void GfxRenderer::displayBuffer(const EInkDisplay::RefreshMode refreshMode) const {
+  einkDisplay.displayBuffer(refreshMode);
+}
+
+void GfxRenderer::displayWindow(const int x, const int y, const int width, const int height) const {
+  // Rotate coordinates from portrait (480x800) to landscape (800x480)
+  // Rotation: 90 degrees clockwise
+  // Portrait coordinates: (x, y) with dimensions (width, height)
+  // Landscape coordinates: (rotatedX, rotatedY) with dimensions (rotatedWidth, rotatedHeight)
+
+  const int rotatedX = y;
+  const int rotatedY = EInkDisplay::DISPLAY_HEIGHT - 1 - x - width + 1;
+  const int rotatedWidth = height;
+  const int rotatedHeight = width;
+
+  einkDisplay.displayWindow(rotatedX, rotatedY, rotatedWidth, rotatedHeight);
+}
+
+// Note: Internal driver treats screen in command orientation, this library treats in portrait orientation
+int GfxRenderer::getScreenWidth() { return EInkDisplay::DISPLAY_HEIGHT; }
+int GfxRenderer::getScreenHeight() { return EInkDisplay::DISPLAY_WIDTH; }
+
+int GfxRenderer::getSpaceWidth(const int fontId) const {
+  if (fontMap.count(fontId) == 0) {
+    Serial.printf("[%lu] [GFX] Font %d not found\n", millis(), fontId);
+    return 0;
+  }
+
+  return fontMap.at(fontId).getGlyph(' ', REGULAR)->advanceX;
+}
+
+int GfxRenderer::getLineHeight(const int fontId) const {
+  if (fontMap.count(fontId) == 0) {
+    Serial.printf("[%lu] [GFX] Font %d not found\n", millis(), fontId);
+    return 0;
+  }
+
+  return fontMap.at(fontId).getData(REGULAR)->advanceY;
+}
+
+uint8_t* GfxRenderer::getFrameBuffer() const { return einkDisplay.getFrameBuffer(); }
+
+size_t GfxRenderer::getBufferSize() { return EInkDisplay::BUFFER_SIZE; }
+
+void GfxRenderer::grayscaleRevert() const { einkDisplay.grayscaleRevert(); }
+
+void GfxRenderer::copyGrayscaleLsbBuffers() const { einkDisplay.copyGrayscaleLsbBuffers(einkDisplay.getFrameBuffer()); }
+
+void GfxRenderer::copyGrayscaleMsbBuffers() const { einkDisplay.copyGrayscaleMsbBuffers(einkDisplay.getFrameBuffer()); }
+
+void GfxRenderer::displayGrayBuffer() const { einkDisplay.displayGrayBuffer(); }
+
+void GfxRenderer::freeBwBufferChunks() {
+  for (auto& bwBufferChunk : bwBufferChunks) {
+    if (bwBufferChunk) {
+      free(bwBufferChunk);
+      bwBufferChunk = nullptr;
+    }
+  }
+}
+
+/**
+ * This should be called before grayscale buffers are populated.
+ * A `restoreBwBuffer` call should always follow the grayscale render if this method was called.
+ * Uses chunked allocation to avoid needing 48KB of contiguous memory.
+ */
+void GfxRenderer::storeBwBuffer() {
+  const uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
+  if (!frameBuffer) {
+    Serial.printf("[%lu] [GFX] !! No framebuffer in storeBwBuffer\n", millis());
+    return;
+  }
+
+  // Allocate and copy each chunk
+  for (size_t i = 0; i < BW_BUFFER_NUM_CHUNKS; i++) {
+    // Check if any chunks are already allocated
+    if (bwBufferChunks[i]) {
+      Serial.printf("[%lu] [GFX] !! BW buffer chunk %zu already stored - this is likely a bug, freeing chunk\n",
+                    millis(), i);
+      free(bwBufferChunks[i]);
+      bwBufferChunks[i] = nullptr;
+    }
+
+    const size_t offset = i * BW_BUFFER_CHUNK_SIZE;
+    bwBufferChunks[i] = static_cast<uint8_t*>(malloc(BW_BUFFER_CHUNK_SIZE));
+
+    if (!bwBufferChunks[i]) {
+      Serial.printf("[%lu] [GFX] !! Failed to allocate BW buffer chunk %zu (%zu bytes)\n", millis(), i,
+                    BW_BUFFER_CHUNK_SIZE);
+      // Free previously allocated chunks
+      freeBwBufferChunks();
+      return;
+    }
+
+    memcpy(bwBufferChunks[i], frameBuffer + offset, BW_BUFFER_CHUNK_SIZE);
+  }
+
+  Serial.printf("[%lu] [GFX] Stored BW buffer in %zu chunks (%zu bytes each)\n", millis(), BW_BUFFER_NUM_CHUNKS,
+                BW_BUFFER_CHUNK_SIZE);
+}
+
+/**
+ * This can only be called if `storeBwBuffer` was called prior to the grayscale render.
+ * It should be called to restore the BW buffer state after grayscale rendering is complete.
+ * Uses chunked restoration to match chunked storage.
+ */
+void GfxRenderer::restoreBwBuffer() {
+  // Check if any all chunks are allocated
+  bool missingChunks = false;
+  for (const auto& bwBufferChunk : bwBufferChunks) {
+    if (!bwBufferChunk) {
+      missingChunks = true;
+      break;
+    }
+  }
+
+  if (missingChunks) {
+    freeBwBufferChunks();
+    return;
+  }
+
+  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
+  if (!frameBuffer) {
+    Serial.printf("[%lu] [GFX] !! No framebuffer in restoreBwBuffer\n", millis());
+    freeBwBufferChunks();
+    return;
+  }
+
+  for (size_t i = 0; i < BW_BUFFER_NUM_CHUNKS; i++) {
+    // Check if chunk is missing
+    if (!bwBufferChunks[i]) {
+      Serial.printf("[%lu] [GFX] !! BW buffer chunks not stored - this is likely a bug\n", millis());
+      freeBwBufferChunks();
+      return;
+    }
+
+    const size_t offset = i * BW_BUFFER_CHUNK_SIZE;
+    memcpy(frameBuffer + offset, bwBufferChunks[i], BW_BUFFER_CHUNK_SIZE);
+  }
+
+  einkDisplay.cleanupGrayscaleBuffers(frameBuffer);
+
+  freeBwBufferChunks();
+  Serial.printf("[%lu] [GFX] Restored and freed BW buffer chunks\n", millis());
+}
+
+void GfxRenderer::renderChar(const EpdFontFamily& fontFamily, const uint32_t cp, int* x, const int* y,
+                             const bool pixelState, const EpdFontStyle style) const {
+  const EpdGlyph* glyph = fontFamily.getGlyph(cp, style);
+  if (!glyph) {
+    // TODO: Replace with fallback glyph property?
+    glyph = fontFamily.getGlyph('?', style);
+  }
+
+  // no glyph?
+  if (!glyph) {
+    Serial.printf("[%lu] [GFX] No glyph for codepoint %d\n", millis(), cp);
+    return;
+  }
+
+  const int is2Bit = fontFamily.getData(style)->is2Bit;
+  const uint32_t offset = glyph->dataOffset;
+  const uint8_t width = glyph->width;
+  const uint8_t height = glyph->height;
+  const int left = glyph->left;
+
+  const uint8_t* bitmap = nullptr;
+  bitmap = &fontFamily.getData(style)->bitmap[offset];
+
+  if (bitmap != nullptr) {
+    for (int glyphY = 0; glyphY < height; glyphY++) {
+      const int screenY = *y - glyph->top + glyphY;
+      for (int glyphX = 0; glyphX < width; glyphX++) {
+        const int pixelPosition = glyphY * width + glyphX;
+        const int screenX = *x + left + glyphX;
+
+        if (is2Bit) {
+          const uint8_t byte = bitmap[pixelPosition / 4];
+          const uint8_t bit_index = (3 - pixelPosition % 4) * 2;
+          // the direct bit from the font is 0 -> white, 1 -> light gray, 2 -> dark gray, 3 -> black
+          // we swap this to better match the way images and screen think about colors:
+          // 0 -> black, 1 -> dark grey, 2 -> light grey, 3 -> white
+          const uint8_t bmpVal = 3 - (byte >> bit_index) & 0x3;
+
+          if (renderMode == BW && bmpVal < 3) {
+            // Black (also paints over the grays in BW mode)
+            drawPixel(screenX, screenY, pixelState);
+          } else if (renderMode == GRAYSCALE_MSB && (bmpVal == 1 || bmpVal == 2)) {
+            // Light gray (also mark the MSB if it's going to be a dark gray too)
+            // We have to flag pixels in reverse for the gray buffers, as 0 leave alone, 1 update
+            drawPixel(screenX, screenY, false);
+          } else if (renderMode == GRAYSCALE_LSB && bmpVal == 1) {
+            // Dark gray
+            drawPixel(screenX, screenY, false);
+          }
+        } else {
+          const uint8_t byte = bitmap[pixelPosition / 8];
+          const uint8_t bit_index = 7 - (pixelPosition % 8);
+
+          if ((byte >> bit_index) & 1) {
+            drawPixel(screenX, screenY, pixelState);
+          }
+        }
+      }
+    }
+  }
+
+  *x += glyph->advanceX;
+}

lib/GfxRenderer/GfxRenderer.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <EInkDisplay.h>
+#include <EpdFontFamily.h>
+#include <FS.h>
+
+#include <map>
+
+#include "Bitmap.h"
+
+class GfxRenderer {
+ public:
+  enum RenderMode { BW, GRAYSCALE_LSB, GRAYSCALE_MSB };
+
+ private:
+  static constexpr size_t BW_BUFFER_CHUNK_SIZE = 8000;  // 8KB chunks to allow for non-contiguous memory
+  static constexpr size_t BW_BUFFER_NUM_CHUNKS = EInkDisplay::BUFFER_SIZE / BW_BUFFER_CHUNK_SIZE;
+  static_assert(BW_BUFFER_CHUNK_SIZE * BW_BUFFER_NUM_CHUNKS == EInkDisplay::BUFFER_SIZE,
+                "BW buffer chunking does not line up with display buffer size");
+
+  EInkDisplay& einkDisplay;
+  RenderMode renderMode;
+  uint8_t* bwBufferChunks[BW_BUFFER_NUM_CHUNKS] = {nullptr};
+  std::map<int, EpdFontFamily> fontMap;
+  void renderChar(const EpdFontFamily& fontFamily, uint32_t cp, int* x, const int* y, bool pixelState,
+                  EpdFontStyle style) const;
+  void freeBwBufferChunks();
+
+ public:
+  explicit GfxRenderer(EInkDisplay& einkDisplay) : einkDisplay(einkDisplay), renderMode(BW) {}
+  ~GfxRenderer() = default;
+
+  // Setup
+  void insertFont(int fontId, EpdFontFamily font);
+
+  // Screen ops
+  static int getScreenWidth();
+  static int getScreenHeight();
+  void displayBuffer(EInkDisplay::RefreshMode refreshMode = EInkDisplay::FAST_REFRESH) const;
+  // EXPERIMENTAL: Windowed update - display only a rectangular region (portrait coordinates)
+  void displayWindow(int x, int y, int width, int height) const;
+  void invertScreen() const;
+  void clearScreen(uint8_t color = 0xFF) const;
+
+  // Drawing
+  void drawPixel(int x, int y, bool state = true) const;
+  void drawLine(int x1, int y1, int x2, int y2, bool state = true) const;
+  void drawRect(int x, int y, int width, int height, bool state = true) const;
+  void fillRect(int x, int y, int width, int height, bool state = true) const;
+  void drawImage(const uint8_t bitmap[], int x, int y, int width, int height) const;
+  void drawBitmap(const Bitmap& bitmap, int x, int y, int maxWidth, int maxHeight) const;
+
+  // Text
+  int getTextWidth(int fontId, const char* text, EpdFontStyle style = REGULAR) const;
+  void drawCenteredText(int fontId, int y, const char* text, bool black = true, EpdFontStyle style = REGULAR) const;
+  void drawText(int fontId, int x, int y, const char* text, bool black = true, EpdFontStyle style = REGULAR) const;
+  int getSpaceWidth(int fontId) const;
+  int getLineHeight(int fontId) const;
+
+  // Grayscale functions
+  void setRenderMode(const RenderMode mode) { this->renderMode = mode; }
+  void copyGrayscaleLsbBuffers() const;
+  void copyGrayscaleMsbBuffers() const;
+  void displayGrayBuffer() const;
+  void storeBwBuffer();
+  void restoreBwBuffer();
+
+  // Low level functions
+  uint8_t* getFrameBuffer() const;
+  static size_t getBufferSize();
+  void grayscaleRevert() const;
+};

lib/JpegToBmpConverter/JpegToBmpConverter.cpp

@@ -0,0 +1,244 @@
+#include "JpegToBmpConverter.h"
+
+#include <picojpeg.h>
+
+#include <cstdio>
+#include <cstring>
+
+// Context structure for picojpeg callback
+struct JpegReadContext {
+  File& file;
+  uint8_t buffer[512];
+  size_t bufferPos;
+  size_t bufferFilled;
+};
+
+// Helper function: Convert 8-bit grayscale to 2-bit (0-3)
+uint8_t JpegToBmpConverter::grayscaleTo2Bit(const uint8_t grayscale) {
+  // Simple threshold mapping:
+  // 0-63 -> 0 (black)
+  // 64-127 -> 1 (dark gray)
+  // 128-191 -> 2 (light gray)
+  // 192-255 -> 3 (white)
+  return grayscale >> 6;
+}
+
+inline void write16(Print& out, const uint16_t value) {
+  // out.write(reinterpret_cast<const uint8_t *>(&value), 2);
+  out.write(value & 0xFF);
+  out.write((value >> 8) & 0xFF);
+}
+
+inline void write32(Print& out, const uint32_t value) {
+  // out.write(reinterpret_cast<const uint8_t *>(&value), 4);
+  out.write(value & 0xFF);
+  out.write((value >> 8) & 0xFF);
+  out.write((value >> 16) & 0xFF);
+  out.write((value >> 24) & 0xFF);
+}
+
+inline void write32Signed(Print& out, const int32_t value) {
+  // out.write(reinterpret_cast<const uint8_t *>(&value), 4);
+  out.write(value & 0xFF);
+  out.write((value >> 8) & 0xFF);
+  out.write((value >> 16) & 0xFF);
+  out.write((value >> 24) & 0xFF);
+}
+
+// Helper function: Write BMP header with 2-bit color depth
+void JpegToBmpConverter::writeBmpHeader(Print& bmpOut, const int width, const int height) {
+  // Calculate row padding (each row must be multiple of 4 bytes)
+  const int bytesPerRow = (width * 2 + 31) / 32 * 4;  // 2 bits per pixel, round up
+  const int imageSize = bytesPerRow * height;
+  const uint32_t fileSize = 70 + imageSize;  // 14 (file header) + 40 (DIB header) + 16 (palette) + image
+
+  // BMP File Header (14 bytes)
+  bmpOut.write('B');
+  bmpOut.write('M');
+  write32(bmpOut, fileSize);  // File size
+  write32(bmpOut, 0);         // Reserved
+  write32(bmpOut, 70);        // Offset to pixel data
+
+  // DIB Header (BITMAPINFOHEADER - 40 bytes)
+  write32(bmpOut, 40);
+  write32Signed(bmpOut, width);
+  write32Signed(bmpOut, -height);  // Negative height = top-down bitmap
+  write16(bmpOut, 1);              // Color planes
+  write16(bmpOut, 2);              // Bits per pixel (2 bits)
+  write32(bmpOut, 0);              // BI_RGB (no compression)
+  write32(bmpOut, imageSize);
+  write32(bmpOut, 2835);  // xPixelsPerMeter (72 DPI)
+  write32(bmpOut, 2835);  // yPixelsPerMeter (72 DPI)
+  write32(bmpOut, 4);     // colorsUsed
+  write32(bmpOut, 4);     // colorsImportant
+
+  // Color Palette (4 colors x 4 bytes = 16 bytes)
+  // Format: Blue, Green, Red, Reserved (BGRA)
+  uint8_t palette[16] = {
+      0x00, 0x00, 0x00, 0x00,  // Color 0: Black
+      0x55, 0x55, 0x55, 0x00,  // Color 1: Dark gray (85)
+      0xAA, 0xAA, 0xAA, 0x00,  // Color 2: Light gray (170)
+      0xFF, 0xFF, 0xFF, 0x00   // Color 3: White
+  };
+  for (const uint8_t i : palette) {
+    bmpOut.write(i);
+  }
+}
+
+// Callback function for picojpeg to read JPEG data
+unsigned char JpegToBmpConverter::jpegReadCallback(unsigned char* pBuf, const unsigned char buf_size,
+                                                   unsigned char* pBytes_actually_read, void* pCallback_data) {
+  auto* context = static_cast<JpegReadContext*>(pCallback_data);
+
+  if (!context || !context->file) {
+    return PJPG_STREAM_READ_ERROR;
+  }
+
+  // Check if we need to refill our context buffer
+  if (context->bufferPos >= context->bufferFilled) {
+    context->bufferFilled = context->file.read(context->buffer, sizeof(context->buffer));
+    context->bufferPos = 0;
+
+    if (context->bufferFilled == 0) {
+      // EOF or error
+      *pBytes_actually_read = 0;
+      return 0;  // Success (EOF is normal)
+    }
+  }
+
+  // Copy available bytes to picojpeg's buffer
+  const size_t available = context->bufferFilled - context->bufferPos;
+  const size_t toRead = available < buf_size ? available : buf_size;
+
+  memcpy(pBuf, context->buffer + context->bufferPos, toRead);
+  context->bufferPos += toRead;
+  *pBytes_actually_read = static_cast<unsigned char>(toRead);
+
+  return 0;  // Success
+}
+
+// Core function: Convert JPEG file to 2-bit BMP
+bool JpegToBmpConverter::jpegFileToBmpStream(File& jpegFile, Print& bmpOut) {
+  Serial.printf("[%lu] [JPG] Converting JPEG to BMP\n", millis());
+
+  // Setup context for picojpeg callback
+  JpegReadContext context = {.file = jpegFile, .bufferPos = 0, .bufferFilled = 0};
+
+  // Initialize picojpeg decoder
+  pjpeg_image_info_t imageInfo;
+  const unsigned char status = pjpeg_decode_init(&imageInfo, jpegReadCallback, &context, 0);
+  if (status != 0) {
+    Serial.printf("[%lu] [JPG] JPEG decode init failed with error code: %d\n", millis(), status);
+    return false;
+  }
+
+  Serial.printf("[%lu] [JPG] JPEG dimensions: %dx%d, components: %d, MCUs: %dx%d\n", millis(), imageInfo.m_width,
+                imageInfo.m_height, imageInfo.m_comps, imageInfo.m_MCUSPerRow, imageInfo.m_MCUSPerCol);
+
+  // Write BMP header
+  writeBmpHeader(bmpOut, imageInfo.m_width, imageInfo.m_height);
+
+  // Calculate row parameters
+  const int bytesPerRow = (imageInfo.m_width * 2 + 31) / 32 * 4;
+
+  // Allocate row buffer for packed 2-bit pixels
+  auto* rowBuffer = static_cast<uint8_t*>(malloc(bytesPerRow));
+  if (!rowBuffer) {
+    Serial.printf("[%lu] [JPG] Failed to allocate row buffer\n", millis());
+    return false;
+  }
+
+  // Allocate a buffer for one MCU row worth of grayscale pixels
+  // This is the minimal memory needed for streaming conversion
+  const int mcuPixelHeight = imageInfo.m_MCUHeight;
+  const int mcuRowPixels = imageInfo.m_width * mcuPixelHeight;
+  auto* mcuRowBuffer = static_cast<uint8_t*>(malloc(mcuRowPixels));
+  if (!mcuRowBuffer) {
+    Serial.printf("[%lu] [JPG] Failed to allocate MCU row buffer\n", millis());
+    free(rowBuffer);
+    return false;
+  }
+
+  // Process MCUs row-by-row and write to BMP as we go (top-down)
+  const int mcuPixelWidth = imageInfo.m_MCUWidth;
+
+  for (int mcuY = 0; mcuY < imageInfo.m_MCUSPerCol; mcuY++) {
+    // Clear the MCU row buffer
+    memset(mcuRowBuffer, 0, mcuRowPixels);
+
+    // Decode one row of MCUs
+    for (int mcuX = 0; mcuX < imageInfo.m_MCUSPerRow; mcuX++) {
+      const unsigned char mcuStatus = pjpeg_decode_mcu();
+      if (mcuStatus != 0) {
+        if (mcuStatus == PJPG_NO_MORE_BLOCKS) {
+          Serial.printf("[%lu] [JPG] Unexpected end of blocks at MCU (%d, %d)\n", millis(), mcuX, mcuY);
+        } else {
+          Serial.printf("[%lu] [JPG] JPEG decode MCU failed at (%d, %d) with error code: %d\n", millis(), mcuX, mcuY,
+                        mcuStatus);
+        }
+        free(mcuRowBuffer);
+        free(rowBuffer);
+        return false;
+      }
+
+      // Process MCU block into MCU row buffer
+      for (int blockY = 0; blockY < mcuPixelHeight; blockY++) {
+        for (int blockX = 0; blockX < mcuPixelWidth; blockX++) {
+          const int pixelX = mcuX * mcuPixelWidth + blockX;
+
+          // Skip pixels outside image width (can happen with MCU alignment)
+          if (pixelX >= imageInfo.m_width) {
+            continue;
+          }
+
+          // Get grayscale value
+          uint8_t gray;
+          if (imageInfo.m_comps == 1) {
+            // Grayscale image
+            gray = imageInfo.m_pMCUBufR[blockY * mcuPixelWidth + blockX];
+          } else {
+            // RGB image - convert to grayscale
+            const uint8_t r = imageInfo.m_pMCUBufR[blockY * mcuPixelWidth + blockX];
+            const uint8_t g = imageInfo.m_pMCUBufG[blockY * mcuPixelWidth + blockX];
+            const uint8_t b = imageInfo.m_pMCUBufB[blockY * mcuPixelWidth + blockX];
+            // Luminance formula: Y = 0.299*R + 0.587*G + 0.114*B
+            // Using integer approximation: (30*R + 59*G + 11*B) / 100
+            gray = (r * 30 + g * 59 + b * 11) / 100;
+          }
+
+          // Store grayscale value in MCU row buffer
+          mcuRowBuffer[blockY * imageInfo.m_width + pixelX] = gray;
+        }
+      }
+    }
+
+    // Write all pixel rows from this MCU row to BMP file
+    const int startRow = mcuY * mcuPixelHeight;
+    const int endRow = (mcuY + 1) * mcuPixelHeight;
+
+    for (int y = startRow; y < endRow && y < imageInfo.m_height; y++) {
+      memset(rowBuffer, 0, bytesPerRow);
+
+      // Pack 4 pixels per byte (2 bits each)
+      for (int x = 0; x < imageInfo.m_width; x++) {
+        const int bufferY = y - startRow;
+        const uint8_t gray = mcuRowBuffer[bufferY * imageInfo.m_width + x];
+        const uint8_t twoBit = grayscaleTo2Bit(gray);
+
+        const int byteIndex = (x * 2) / 8;
+        const int bitOffset = 6 - ((x * 2) % 8);  // 6, 4, 2, 0
+        rowBuffer[byteIndex] |= (twoBit << bitOffset);
+      }
+
+      // Write row with padding
+      bmpOut.write(rowBuffer, bytesPerRow);
+    }
+  }
+
+  // Clean up
+  free(mcuRowBuffer);
+  free(rowBuffer);
+
+  Serial.printf("[%lu] [JPG] Successfully converted JPEG to BMP\n", millis());
+  return true;
+}

lib/JpegToBmpConverter/JpegToBmpConverter.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <FS.h>
+
+class ZipFile;
+
+class JpegToBmpConverter {
+  static void writeBmpHeader(Print& bmpOut, int width, int height);
+  static uint8_t grayscaleTo2Bit(uint8_t grayscale);
+  static unsigned char jpegReadCallback(unsigned char* pBuf, unsigned char buf_size,
+                                        unsigned char* pBytes_actually_read, void* pCallback_data);
+
+ public:
+  static bool jpegFileToBmpStream(File& jpegFile, Print& bmpOut);
+};

lib/ZipFile/ZipFile.cpp

@@ -7,7 +7,7 @@ bool inflateOneShot(const uint8_t* inputBuf, const size_t deflatedSize, uint8_t*
   // Setup inflator
   const auto inflator = static_cast<tinfl_decompressor*>(malloc(sizeof(tinfl_decompressor)));
   if (!inflator) {
-    Serial.println("Failed to allocate memory for inflator");
+    Serial.printf("[%lu] [ZIP] Failed to allocate memory for inflator\n", millis());
     return false;
   }
   memset(inflator, 0, sizeof(tinfl_decompressor));
@@ -20,36 +20,35 @@ bool inflateOneShot(const uint8_t* inputBuf, const size_t deflatedSize, uint8_t*
   free(inflator);
 
   if (status != TINFL_STATUS_DONE) {
-    Serial.printf("tinfl_decompress() failed with status %d\n", status);
+    Serial.printf("[%lu] [ZIP] tinfl_decompress() failed with status %d\n", millis(), status);
     return false;
   }
 
   return true;
 }
 
-bool ZipFile::loadFileStat(const char* filename, mz_zip_archive_file_stat* fileStat) const {
+ZipFile::ZipFile(std::string filePath) : filePath(std::move(filePath)) {
-  mz_zip_archive zipArchive = {};
+  const bool status = mz_zip_reader_init_file(&zipArchive, this->filePath.c_str(), 0);
-  const bool status = mz_zip_reader_init_file(&zipArchive, filePath.c_str(), 0);
 
   if (!status) {
-    Serial.printf("mz_zip_reader_init_file() failed!\nError %s\n", mz_zip_get_error_string(zipArchive.m_last_error));
+    Serial.printf("[%lu] [ZIP] mz_zip_reader_init_file() failed for %s! Error: %s\n", millis(), this->filePath.c_str(),
-    return false;
+                  mz_zip_get_error_string(zipArchive.m_last_error));
   }
+}
 
+bool ZipFile::loadFileStat(const char* filename, mz_zip_archive_file_stat* fileStat) const {
   // find the file
   mz_uint32 fileIndex = 0;
   if (!mz_zip_reader_locate_file_v2(&zipArchive, filename, nullptr, 0, &fileIndex)) {
-    Serial.printf("Could not find file %s\n", filename);
+    Serial.printf("[%lu] [ZIP] Could not find file %s\n", millis(), filename);
-    mz_zip_reader_end(&zipArchive);
     return false;
   }
 
   if (!mz_zip_reader_file_stat(&zipArchive, fileIndex, fileStat)) {
-    Serial.printf("mz_zip_reader_file_stat() failed!\nError %s\n", mz_zip_get_error_string(zipArchive.m_last_error));
+    Serial.printf("[%lu] [ZIP] mz_zip_reader_file_stat() failed! Error: %s\n", millis(),
-    mz_zip_reader_end(&zipArchive);
+                  mz_zip_get_error_string(zipArchive.m_last_error));
     return false;
   }
-  mz_zip_reader_end(&zipArchive);
   return true;
 }
 
@@ -60,18 +59,22 @@ long ZipFile::getDataOffset(const mz_zip_archive_file_stat& fileStat) const {
   const uint64_t fileOffset = fileStat.m_local_header_ofs;
 
   FILE* file = fopen(filePath.c_str(), "r");
+  if (!file) {
+    Serial.printf("[%lu] [ZIP] Failed to open file for reading local header\n", millis());
+    return -1;
+  }
   fseek(file, fileOffset, SEEK_SET);
   const size_t read = fread(pLocalHeader, 1, localHeaderSize, file);
   fclose(file);
 
   if (read != localHeaderSize) {
-    Serial.println("Something went wrong reading the local header");
+    Serial.printf("[%lu] [ZIP] Something went wrong reading the local header\n", millis());
     return -1;
   }
 
   if (pLocalHeader[0] + (pLocalHeader[1] << 8) + (pLocalHeader[2] << 16) + (pLocalHeader[3] << 24) !=
       0x04034b50 /* MZ_ZIP_LOCAL_DIR_HEADER_SIG */) {
-    Serial.println("Not a valid zip file header");
+    Serial.printf("[%lu] [ZIP] Not a valid zip file header\n", millis());
     return -1;
   }
 
@@ -80,6 +83,16 @@ long ZipFile::getDataOffset(const mz_zip_archive_file_stat& fileStat) const {
   return fileOffset + localHeaderSize + filenameLength + extraOffset;
 }
 
+bool ZipFile::getInflatedFileSize(const char* filename, size_t* size) const {
+  mz_zip_archive_file_stat fileStat;
+  if (!loadFileStat(filename, &fileStat)) {
+    return false;
+  }
+
+  *size = static_cast<size_t>(fileStat.m_uncomp_size);
+  return true;
+}
+
 uint8_t* ZipFile::readFileToMemory(const char* filename, size_t* size, const bool trailingNullByte) const {
   mz_zip_archive_file_stat fileStat;
   if (!loadFileStat(filename, &fileStat)) {
@@ -92,12 +105,21 @@ uint8_t* ZipFile::readFileToMemory(const char* filename, size_t* size, const boo
   }
 
   FILE* file = fopen(filePath.c_str(), "rb");
+  if (!file) {
+    Serial.printf("[%lu] [ZIP] Failed to open file for reading\n", millis());
+    return nullptr;
+  }
   fseek(file, fileOffset, SEEK_SET);
 
   const auto deflatedDataSize = static_cast<size_t>(fileStat.m_comp_size);
   const auto inflatedDataSize = static_cast<size_t>(fileStat.m_uncomp_size);
   const auto dataSize = trailingNullByte ? inflatedDataSize + 1 : inflatedDataSize;
   const auto data = static_cast<uint8_t*>(malloc(dataSize));
+  if (data == nullptr) {
+    Serial.printf("[%lu] [ZIP] Failed to allocate memory for output buffer (%zu bytes)\n", millis(), dataSize);
+    fclose(file);
+    return nullptr;
+  }
 
   if (fileStat.m_method == MZ_NO_COMPRESSION) {
     // no deflation, just read content
@@ -105,7 +127,7 @@ uint8_t* ZipFile::readFileToMemory(const char* filename, size_t* size, const boo
     fclose(file);
 
     if (dataRead != inflatedDataSize) {
-      Serial.println("Failed to read data");
+      Serial.printf("[%lu] [ZIP] Failed to read data\n", millis());
       free(data);
       return nullptr;
     }
@@ -115,7 +137,7 @@ uint8_t* ZipFile::readFileToMemory(const char* filename, size_t* size, const boo
     // Read out deflated content from file
     const auto deflatedData = static_cast<uint8_t*>(malloc(deflatedDataSize));
     if (deflatedData == nullptr) {
-      Serial.println("Failed to allocate memory for decompression buffer");
+      Serial.printf("[%lu] [ZIP] Failed to allocate memory for decompression buffer\n", millis());
       fclose(file);
       return nullptr;
     }
@@ -124,7 +146,7 @@ uint8_t* ZipFile::readFileToMemory(const char* filename, size_t* size, const boo
     fclose(file);
 
     if (dataRead != deflatedDataSize) {
-      Serial.printf("Failed to read data, expected %d got %d\n", deflatedDataSize, dataRead);
+      Serial.printf("[%lu] [ZIP] Failed to read data, expected %d got %d\n", millis(), deflatedDataSize, dataRead);
       free(deflatedData);
       free(data);
       return nullptr;
@@ -134,14 +156,14 @@ uint8_t* ZipFile::readFileToMemory(const char* filename, size_t* size, const boo
     free(deflatedData);
 
     if (!success) {
-      Serial.println("Failed to inflate file");
+      Serial.printf("[%lu] [ZIP] Failed to inflate file\n", millis());
       free(data);
       return nullptr;
     }
 
     // Continue out of block with data set
   } else {
-    Serial.println("Unsupported compression method");
+    Serial.printf("[%lu] [ZIP] Unsupported compression method\n", millis());
     fclose(file);
     return nullptr;
   }
@@ -163,6 +185,10 @@ bool ZipFile::readFileToStream(const char* filename, Print& out, const size_t ch
   }
 
   FILE* file = fopen(filePath.c_str(), "rb");
+  if (!file) {
+    Serial.printf("[%lu] [ZIP] Failed to open file for streaming\n", millis());
+    return false;
+  }
   fseek(file, fileOffset, SEEK_SET);
 
   const auto deflatedDataSize = static_cast<size_t>(fileStat.m_comp_size);
@@ -172,7 +198,7 @@ bool ZipFile::readFileToStream(const char* filename, Print& out, const size_t ch
     // no deflation, just read content
     const auto buffer = static_cast<uint8_t*>(malloc(chunkSize));
     if (!buffer) {
-      Serial.println("Failed to allocate memory for buffer");
+      Serial.printf("[%lu] [ZIP] Failed to allocate memory for buffer\n", millis());
       fclose(file);
       return false;
     }
@@ -181,7 +207,7 @@ bool ZipFile::readFileToStream(const char* filename, Print& out, const size_t ch
     while (remaining > 0) {
       const size_t dataRead = fread(buffer, 1, remaining < chunkSize ? remaining : chunkSize, file);
       if (dataRead == 0) {
-        Serial.println("Could not read more bytes");
+        Serial.printf("[%lu] [ZIP] Could not read more bytes\n", millis());
         free(buffer);
         fclose(file);
         return false;
@@ -200,7 +226,7 @@ bool ZipFile::readFileToStream(const char* filename, Print& out, const size_t ch
     // Setup inflator
     const auto inflator = static_cast<tinfl_decompressor*>(malloc(sizeof(tinfl_decompressor)));
     if (!inflator) {
-      Serial.println("Failed to allocate memory for inflator");
+      Serial.printf("[%lu] [ZIP] Failed to allocate memory for inflator\n", millis());
       fclose(file);
       return false;
     }
@@ -210,7 +236,7 @@ bool ZipFile::readFileToStream(const char* filename, Print& out, const size_t ch
     // Setup file read buffer
     const auto fileReadBuffer = static_cast<uint8_t*>(malloc(chunkSize));
     if (!fileReadBuffer) {
-      Serial.println("Failed to allocate memory for zip file read buffer");
+      Serial.printf("[%lu] [ZIP] Failed to allocate memory for zip file read buffer\n", millis());
       free(inflator);
       fclose(file);
       return false;
@@ -218,7 +244,7 @@ bool ZipFile::readFileToStream(const char* filename, Print& out, const size_t ch
 
     const auto outputBuffer = static_cast<uint8_t*>(malloc(TINFL_LZ_DICT_SIZE));
     if (!outputBuffer) {
-      Serial.println("Failed to allocate memory for dictionary");
+      Serial.printf("[%lu] [ZIP] Failed to allocate memory for dictionary\n", millis());
       free(inflator);
       free(fileReadBuffer);
       fclose(file);
@@ -266,16 +292,20 @@ bool ZipFile::readFileToStream(const char* filename, Print& out, const size_t ch
       // Write output chunk
       if (outBytes > 0) {
         processedOutputBytes += outBytes;
-        out.write(outputBuffer + outputCursor, outBytes);
+        if (out.write(outputBuffer + outputCursor, outBytes) != outBytes) {
+          Serial.printf("[%lu] [ZIP] Failed to write all output bytes to stream\n", millis());
+          fclose(file);
+          free(outputBuffer);
+          free(fileReadBuffer);
+          free(inflator);
+          return false;
+        }
         // Update output position in buffer (with wraparound)
         outputCursor = (outputCursor + outBytes) & (TINFL_LZ_DICT_SIZE - 1);
       }
 
-      Serial.printf("Decompressing - %d/%d deflated into %d/%d inflated\n", deflatedDataSize - fileRemainingBytes,
-                    deflatedDataSize, processedOutputBytes, inflatedDataSize);
-
       if (status < 0) {
-        Serial.printf("tinfl_decompress() failed with status %d\n", status);
+        Serial.printf("[%lu] [ZIP] tinfl_decompress() failed with status %d\n", millis(), status);
         fclose(file);
         free(outputBuffer);
         free(fileReadBuffer);
@@ -284,7 +314,8 @@ bool ZipFile::readFileToStream(const char* filename, Print& out, const size_t ch
       }
 
       if (status == TINFL_STATUS_DONE) {
-        Serial.println("Decompression finished");
+        Serial.printf("[%lu] [ZIP] Decompressed %d bytes into %d bytes\n", millis(), deflatedDataSize,
+                      inflatedDataSize);
         fclose(file);
         free(inflator);
         free(fileReadBuffer);
@@ -294,7 +325,7 @@ bool ZipFile::readFileToStream(const char* filename, Print& out, const size_t ch
     }
 
     // If we get here, EOF reached without TINFL_STATUS_DONE
-    Serial.println("Unexpected EOF");
+    Serial.printf("[%lu] [ZIP] Unexpected EOF\n", millis());
     fclose(file);
     free(outputBuffer);
     free(fileReadBuffer);
@@ -302,6 +333,6 @@ bool ZipFile::readFileToStream(const char* filename, Print& out, const size_t ch
     return false;
   }
 
-  Serial.println("Unsupported compression method");
+  Serial.printf("[%lu] [ZIP] Unsupported compression method\n", millis());
   return false;
 }

lib/ZipFile/ZipFile.h

@@ -1,19 +1,20 @@
 #pragma once
 #include <Print.h>
 
-#include <functional>
 #include <string>
 
 #include "miniz.h"
 
 class ZipFile {
   std::string filePath;
+  mutable mz_zip_archive zipArchive = {};
   bool loadFileStat(const char* filename, mz_zip_archive_file_stat* fileStat) const;
   long getDataOffset(const mz_zip_archive_file_stat& fileStat) const;
 
  public:
-  explicit ZipFile(std::string filePath) : filePath(std::move(filePath)) {}
+  explicit ZipFile(std::string filePath);
-  ~ZipFile() = default;
+  ~ZipFile() { mz_zip_reader_end(&zipArchive); }
+  bool getInflatedFileSize(const char* filename, size_t* size) const;
   uint8_t* readFileToMemory(const char* filename, size_t* size = nullptr, bool trailingNullByte = false) const;
   bool readFileToStream(const char* filename, Print& out, size_t chunkSize) const;
 };

lib/picojpeg/picojpeg.h

@@ -0,0 +1,124 @@
+//------------------------------------------------------------------------------
+// picojpeg - Public domain, Rich Geldreich <richgel99@gmail.com>
+//------------------------------------------------------------------------------
+#ifndef PICOJPEG_H
+#define PICOJPEG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Error codes
+enum {
+  PJPG_NO_MORE_BLOCKS = 1,
+  PJPG_BAD_DHT_COUNTS,
+  PJPG_BAD_DHT_INDEX,
+  PJPG_BAD_DHT_MARKER,
+  PJPG_BAD_DQT_MARKER,
+  PJPG_BAD_DQT_TABLE,
+  PJPG_BAD_PRECISION,
+  PJPG_BAD_HEIGHT,
+  PJPG_BAD_WIDTH,
+  PJPG_TOO_MANY_COMPONENTS,
+  PJPG_BAD_SOF_LENGTH,
+  PJPG_BAD_VARIABLE_MARKER,
+  PJPG_BAD_DRI_LENGTH,
+  PJPG_BAD_SOS_LENGTH,
+  PJPG_BAD_SOS_COMP_ID,
+  PJPG_W_EXTRA_BYTES_BEFORE_MARKER,
+  PJPG_NO_ARITHMITIC_SUPPORT,
+  PJPG_UNEXPECTED_MARKER,
+  PJPG_NOT_JPEG,
+  PJPG_UNSUPPORTED_MARKER,
+  PJPG_BAD_DQT_LENGTH,
+  PJPG_TOO_MANY_BLOCKS,
+  PJPG_UNDEFINED_QUANT_TABLE,
+  PJPG_UNDEFINED_HUFF_TABLE,
+  PJPG_NOT_SINGLE_SCAN,
+  PJPG_UNSUPPORTED_COLORSPACE,
+  PJPG_UNSUPPORTED_SAMP_FACTORS,
+  PJPG_DECODE_ERROR,
+  PJPG_BAD_RESTART_MARKER,
+  PJPG_ASSERTION_ERROR,
+  PJPG_BAD_SOS_SPECTRAL,
+  PJPG_BAD_SOS_SUCCESSIVE,
+  PJPG_STREAM_READ_ERROR,
+  PJPG_NOTENOUGHMEM,
+  PJPG_UNSUPPORTED_COMP_IDENT,
+  PJPG_UNSUPPORTED_QUANT_TABLE,
+  PJPG_UNSUPPORTED_MODE,  // picojpeg doesn't support progressive JPEG's
+};
+
+// Scan types
+typedef enum { PJPG_GRAYSCALE, PJPG_YH1V1, PJPG_YH2V1, PJPG_YH1V2, PJPG_YH2V2 } pjpeg_scan_type_t;
+
+typedef struct {
+  // Image resolution
+  int m_width;
+  int m_height;
+
+  // Number of components (1 or 3)
+  int m_comps;
+
+  // Total number of minimum coded units (MCU's) per row/col.
+  int m_MCUSPerRow;
+  int m_MCUSPerCol;
+
+  // Scan type
+  pjpeg_scan_type_t m_scanType;
+
+  // MCU width/height in pixels (each is either 8 or 16 depending on the scan type)
+  int m_MCUWidth;
+  int m_MCUHeight;
+
+  // m_pMCUBufR, m_pMCUBufG, and m_pMCUBufB are pointers to internal MCU Y or RGB pixel component buffers.
+  // Each time pjpegDecodeMCU() is called successfully these buffers will be filled with 8x8 pixel blocks of Y or RGB
+  // pixels. Each MCU consists of (m_MCUWidth/8)*(m_MCUHeight/8) Y/RGB blocks: 1 for greyscale/no subsampling, 2 for
+  // H1V2/H2V1, or 4 blocks for H2V2 sampling factors. Each block is a contiguous array of 64 (8x8) bytes of a single
+  // component: either Y for grayscale images, or R, G or B components for color images.
+  //
+  // The 8x8 pixel blocks are organized in these byte arrays like this:
+  //
+  // PJPG_GRAYSCALE: Each MCU is decoded to a single block of 8x8 grayscale pixels.
+  // Only the values in m_pMCUBufR are valid. Each 8 bytes is a row of pixels (raster order: left to right, top to
+  // bottom) from the 8x8 block.
+  //
+  // PJPG_H1V1: Each MCU contains is decoded to a single block of 8x8 RGB pixels.
+  //
+  // PJPG_YH2V1: Each MCU is decoded to 2 blocks, or 16x8 pixels.
+  // The 2 RGB blocks are at byte offsets: 0, 64
+  //
+  // PJPG_YH1V2: Each MCU is decoded to 2 blocks, or 8x16 pixels.
+  // The 2 RGB blocks are at byte offsets: 0,
+  //                                       128
+  //
+  // PJPG_YH2V2: Each MCU is decoded to 4 blocks, or 16x16 pixels.
+  // The 2x2 block array is organized at byte offsets:   0,  64,
+  //                                                   128, 192
+  //
+  // It is up to the caller to copy or blit these pixels from these buffers into the destination bitmap.
+  unsigned char* m_pMCUBufR;
+  unsigned char* m_pMCUBufG;
+  unsigned char* m_pMCUBufB;
+} pjpeg_image_info_t;
+
+typedef unsigned char (*pjpeg_need_bytes_callback_t)(unsigned char* pBuf, unsigned char buf_size,
+                                                     unsigned char* pBytes_actually_read, void* pCallback_data);
+
+// Initializes the decompressor. Returns 0 on success, or one of the above error codes on failure.
+// pNeed_bytes_callback will be called to fill the decompressor's internal input buffer.
+// If reduce is 1, only the first pixel of each block will be decoded. This mode is much faster because it skips the AC
+// dequantization, IDCT and chroma upsampling of every image pixel. Not thread safe.
+unsigned char pjpeg_decode_init(pjpeg_image_info_t* pInfo, pjpeg_need_bytes_callback_t pNeed_bytes_callback,
+                                void* pCallback_data, unsigned char reduce);
+
+// Decompresses the file's next MCU. Returns 0 on success, PJPG_NO_MORE_BLOCKS if no more blocks are available, or an
+// error code. Must be called a total of m_MCUSPerRow*m_MCUSPerCol times to completely decompress the image. Not thread
+// safe.
+unsigned char pjpeg_decode_mcu(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // PICOJPEG_H

platformio.ini

@@ -1,40 +1,53 @@
-; PlatformIO Project Configuration File
+[platformio]
-;
+crosspoint_version = 0.8.0
-;   Build options: build flags, source filter
+default_envs = default
-;   Upload options: custom upload port, speed and extra flags
-;   Library options: dependencies, extra library storages
-;   Advanced options: extra scripting
-;
-; Please visit documentation for the other options and examples
-; https://docs.platformio.org/page/projectconf.html
 
-[env:esp32-c3-devkitm-1]
+[base]
 platform = espressif32
 board = esp32-c3-devkitm-1
 framework = arduino
 monitor_speed = 115200
 upload_speed = 921600
+check_tool = cppcheck
+check_flags = --enable=all --suppress=missingIncludeSystem --suppress=unusedFunction --suppress=unmatchedSuppression --inline-suppr
+check_skip_packages = yes
 
 board_upload.flash_size = 16MB
 board_upload.maximum_size = 16777216
 board_upload.offset_address = 0x10000
 
+build_flags =
+  -DARDUINO_USB_MODE=1
+  -DARDUINO_USB_CDC_ON_BOOT=1
+  -DMINIZ_NO_ZLIB_COMPATIBLE_NAMES=1
+  -DEINK_DISPLAY_SINGLE_BUFFER_MODE=1
+# https://libexpat.github.io/doc/api/latest/#XML_GE
+  -DXML_GE=0
+  -DXML_CONTEXT_BYTES=1024
+  -std=c++2a
+
 ; Board configuration
 board_build.flash_mode = dio
 board_build.flash_size = 16MB
 board_build.partitions = partitions.csv
 
-build_flags =
+extra_scripts =
-  -DARDUINO_USB_MODE=1
+  pre:scripts/build_html.py
-  -DARDUINO_USB_CDC_ON_BOOT=1
-  -DMINIZ_NO_ZLIB_COMPATIBLE_NAMES=1
-  # https://libexpat.github.io/doc/api/latest/#XML_GE
-  -DXML_GE=0
-  -DXML_CONTEXT_BYTES=1024
 
 ; Libraries
 lib_deps =
-  zinggjm/GxEPD2@^1.6.5
-  https://github.com/leethomason/tinyxml2.git#11.0.0
   BatteryMonitor=symlink://open-x4-sdk/libs/hardware/BatteryMonitor
   InputManager=symlink://open-x4-sdk/libs/hardware/InputManager
+  EInkDisplay=symlink://open-x4-sdk/libs/display/EInkDisplay
+
+[env:default]
+extends = base
+build_flags =
+  ${base.build_flags}
+  -DCROSSPOINT_VERSION=\"${platformio.crosspoint_version}-dev\"
+
+[env:gh_release]
+extends = base
+build_flags =
+  ${base.build_flags}
+  -DCROSSPOINT_VERSION=\"${platformio.crosspoint_version}\"

scripts/build_html.py

@@ -0,0 +1,51 @@
+import os
+import re
+
+SRC_DIR = "src"
+
+def minify_html(html: str) -> str:
+    # Tags where whitespace should be preserved
+    preserve_tags = ['pre', 'code', 'textarea', 'script', 'style']
+    preserve_regex = '|'.join(preserve_tags)
+
+    # Protect preserve blocks with placeholders
+    preserve_blocks = []
+    def preserve(match):
+        preserve_blocks.append(match.group(0))
+        return f"__PRESERVE_BLOCK_{len(preserve_blocks)-1}__"
+
+    html = re.sub(rf'<({preserve_regex})[\s\S]*?</\1>', preserve, html, flags=re.IGNORECASE)
+
+    # Remove HTML comments
+    html = re.sub(r'<!--.*?-->', '', html, flags=re.DOTALL)
+
+    # Collapse all whitespace between tags
+    html = re.sub(r'>\s+<', '><', html)
+
+    # Collapse multiple spaces inside tags
+    html = re.sub(r'\s+', ' ', html)
+
+    # Restore preserved blocks
+    for i, block in enumerate(preserve_blocks):
+        html = html.replace(f"__PRESERVE_BLOCK_{i}__", block)
+
+    return html.strip()
+
+for root, _, files in os.walk(SRC_DIR):
+    for file in files:
+        if file.endswith(".html"):
+            html_path = os.path.join(root, file)
+            with open(html_path, "r", encoding="utf-8") as f:
+                html_content = f.read()
+
+            # minified = regex.sub("\g<1>", html_content)
+            minified = minify_html(html_content)
+            base_name = f"{os.path.splitext(file)[0]}Html"
+            header_path = os.path.join(root, f"{base_name}.generated.h")
+
+            with open(header_path, "w", encoding="utf-8") as h:
+                h.write(f"// THIS FILE IS AUTOGENERATED, DO NOT EDIT MANUALLY\n\n")
+                h.write(f"#pragma once\n")
+                h.write(f'constexpr char {base_name}[] PROGMEM = R"rawliteral({minified})rawliteral";\n')
+
+            print(f"Generated: {header_path}")

src/CrossPointSettings.cpp

@@ -0,0 +1,68 @@
+#include "CrossPointSettings.h"
+
+#include <HardwareSerial.h>
+#include <SD.h>
+#include <Serialization.h>
+
+#include <cstdint>
+#include <fstream>
+
+// Initialize the static instance
+CrossPointSettings CrossPointSettings::instance;
+
+namespace {
+constexpr uint8_t SETTINGS_FILE_VERSION = 1;
+constexpr uint8_t SETTINGS_COUNT = 3;
+constexpr char SETTINGS_FILE[] = "/sd/.crosspoint/settings.bin";
+}  // namespace
+
+bool CrossPointSettings::saveToFile() const {
+  // Make sure the directory exists
+  SD.mkdir("/.crosspoint");
+
+  std::ofstream outputFile(SETTINGS_FILE);
+  serialization::writePod(outputFile, SETTINGS_FILE_VERSION);
+  serialization::writePod(outputFile, SETTINGS_COUNT);
+  serialization::writePod(outputFile, sleepScreen);
+  serialization::writePod(outputFile, extraParagraphSpacing);
+  serialization::writePod(outputFile, shortPwrBtn);
+  outputFile.close();
+
+  Serial.printf("[%lu] [CPS] Settings saved to file\n", millis());
+  return true;
+}
+
+bool CrossPointSettings::loadFromFile() {
+  if (!SD.exists(SETTINGS_FILE + 3)) {  // +3 to skip "/sd" prefix
+    Serial.printf("[%lu] [CPS] Settings file does not exist, using defaults\n", millis());
+    return false;
+  }
+
+  std::ifstream inputFile(SETTINGS_FILE);
+
+  uint8_t version;
+  serialization::readPod(inputFile, version);
+  if (version != SETTINGS_FILE_VERSION) {
+    Serial.printf("[%lu] [CPS] Deserialization failed: Unknown version %u\n", millis(), version);
+    inputFile.close();
+    return false;
+  }
+
+  uint8_t fileSettingsCount = 0;
+  serialization::readPod(inputFile, fileSettingsCount);
+
+  // load settings that exist
+  uint8_t settingsRead = 0;
+  do {
+    serialization::readPod(inputFile, sleepScreen);
+    if (++settingsRead >= fileSettingsCount) break;
+    serialization::readPod(inputFile, extraParagraphSpacing);
+    if (++settingsRead >= fileSettingsCount) break;
+    serialization::readPod(inputFile, shortPwrBtn);
+    if (++settingsRead >= fileSettingsCount) break;
+  } while (false);
+
+  inputFile.close();
+  Serial.printf("[%lu] [CPS] Settings loaded from file\n", millis());
+  return true;
+}

src/CrossPointSettings.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <cstdint>
+#include <iosfwd>
+
+class CrossPointSettings {
+ private:
+  // Private constructor for singleton
+  CrossPointSettings() = default;
+
+  // Static instance
+  static CrossPointSettings instance;
+
+ public:
+  // Delete copy constructor and assignment
+  CrossPointSettings(const CrossPointSettings&) = delete;
+  CrossPointSettings& operator=(const CrossPointSettings&) = delete;
+
+  // Should match with SettingsActivity text
+  enum SLEEP_SCREEN_MODE { DARK = 0, LIGHT = 1, CUSTOM = 2, COVER = 3 };
+
+  // Sleep screen settings
+  uint8_t sleepScreen = DARK;
+  // Text rendering settings
+  uint8_t extraParagraphSpacing = 1;
+  // Duration of the power button press
+  uint8_t shortPwrBtn = 0;
+
+  ~CrossPointSettings() = default;
+
+  // Get singleton instance
+  static CrossPointSettings& getInstance() { return instance; }
+
+  uint16_t getPowerButtonDuration() const { return shortPwrBtn ? 10 : 500; }
+
+  bool saveToFile() const;
+  bool loadFromFile();
+};
+
+// Helper macro to access settings
+#define SETTINGS CrossPointSettings::getInstance()

src/CrossPointState.cpp

@@ -6,8 +6,12 @@
 
 #include <fstream>
 
+namespace {
 constexpr uint8_t STATE_FILE_VERSION = 1;
 constexpr char STATE_FILE[] = "/sd/.crosspoint/state.bin";
+}  // namespace
+
+CrossPointState CrossPointState::instance;
 
 bool CrossPointState::saveToFile() const {
   std::ofstream outputFile(STATE_FILE);
@@ -23,7 +27,7 @@ bool CrossPointState::loadFromFile() {
   uint8_t version;
   serialization::readPod(inputFile, version);
   if (version != STATE_FILE_VERSION) {
-    Serial.printf("CrossPointState: Unknown version %u\n", version);
+    Serial.printf("[%lu] [CPS] Deserialization failed: Unknown version %u\n", millis(), version);
     inputFile.close();
     return false;
   }

src/CrossPointState.h

@@ -3,11 +3,20 @@
 #include <string>
 
 class CrossPointState {
+  // Static instance
+  static CrossPointState instance;
+
  public:
   std::string openEpubPath;
   ~CrossPointState() = default;
 
+  // Get singleton instance
+  static CrossPointState& getInstance() { return instance; }
+
   bool saveToFile() const;
 
   bool loadFromFile();
 };
+
+// Helper macro to access settings
+#define APP_STATE CrossPointState::getInstance()

src/WifiCredentialStore.cpp

@@ -0,0 +1,162 @@
+#include "WifiCredentialStore.h"
+
+#include <HardwareSerial.h>
+#include <SD.h>
+#include <Serialization.h>
+
+#include <fstream>
+
+// Initialize the static instance
+WifiCredentialStore WifiCredentialStore::instance;
+
+namespace {
+// File format version
+constexpr uint8_t WIFI_FILE_VERSION = 1;
+
+// WiFi credentials file path
+constexpr char WIFI_FILE[] = "/sd/.crosspoint/wifi.bin";
+
+// Obfuscation key - "CrossPoint" in ASCII
+// This is NOT cryptographic security, just prevents casual file reading
+constexpr uint8_t OBFUSCATION_KEY[] = {0x43, 0x72, 0x6F, 0x73, 0x73, 0x50, 0x6F, 0x69, 0x6E, 0x74};
+constexpr size_t KEY_LENGTH = sizeof(OBFUSCATION_KEY);
+}  // namespace
+
+void WifiCredentialStore::obfuscate(std::string& data) const {
+  Serial.printf("[%lu] [WCS] Obfuscating/deobfuscating %zu bytes\n", millis(), data.size());
+  for (size_t i = 0; i < data.size(); i++) {
+    data[i] ^= OBFUSCATION_KEY[i % KEY_LENGTH];
+  }
+}
+
+bool WifiCredentialStore::saveToFile() const {
+  // Make sure the directory exists
+  SD.mkdir("/.crosspoint");
+
+  std::ofstream file(WIFI_FILE, std::ios::binary);
+  if (!file) {
+    Serial.printf("[%lu] [WCS] Failed to open wifi.bin for writing\n", millis());
+    return false;
+  }
+
+  // Write header
+  serialization::writePod(file, WIFI_FILE_VERSION);
+  serialization::writePod(file, static_cast<uint8_t>(credentials.size()));
+
+  // Write each credential
+  for (const auto& cred : credentials) {
+    // Write SSID (plaintext - not sensitive)
+    serialization::writeString(file, cred.ssid);
+    Serial.printf("[%lu] [WCS] Saving SSID: %s, password length: %zu\n", millis(), cred.ssid.c_str(),
+                  cred.password.size());
+
+    // Write password (obfuscated)
+    std::string obfuscatedPwd = cred.password;
+    obfuscate(obfuscatedPwd);
+    serialization::writeString(file, obfuscatedPwd);
+  }
+
+  file.close();
+  Serial.printf("[%lu] [WCS] Saved %zu WiFi credentials to file\n", millis(), credentials.size());
+  return true;
+}
+
+bool WifiCredentialStore::loadFromFile() {
+  if (!SD.exists(WIFI_FILE + 3)) {  // +3 to skip "/sd" prefix
+    Serial.printf("[%lu] [WCS] WiFi credentials file does not exist\n", millis());
+    return false;
+  }
+
+  std::ifstream file(WIFI_FILE, std::ios::binary);
+  if (!file) {
+    Serial.printf("[%lu] [WCS] Failed to open wifi.bin for reading\n", millis());
+    return false;
+  }
+
+  // Read and verify version
+  uint8_t version;
+  serialization::readPod(file, version);
+  if (version != WIFI_FILE_VERSION) {
+    Serial.printf("[%lu] [WCS] Unknown file version: %u\n", millis(), version);
+    file.close();
+    return false;
+  }
+
+  // Read credential count
+  uint8_t count;
+  serialization::readPod(file, count);
+
+  // Read credentials
+  credentials.clear();
+  for (uint8_t i = 0; i < count && i < MAX_NETWORKS; i++) {
+    WifiCredential cred;
+
+    // Read SSID
+    serialization::readString(file, cred.ssid);
+
+    // Read and deobfuscate password
+    serialization::readString(file, cred.password);
+    Serial.printf("[%lu] [WCS] Loaded SSID: %s, obfuscated password length: %zu\n", millis(), cred.ssid.c_str(),
+                  cred.password.size());
+    obfuscate(cred.password);  // XOR is symmetric, so same function deobfuscates
+    Serial.printf("[%lu] [WCS] After deobfuscation, password length: %zu\n", millis(), cred.password.size());
+
+    credentials.push_back(cred);
+  }
+
+  file.close();
+  Serial.printf("[%lu] [WCS] Loaded %zu WiFi credentials from file\n", millis(), credentials.size());
+  return true;
+}
+
+bool WifiCredentialStore::addCredential(const std::string& ssid, const std::string& password) {
+  // Check if this SSID already exists and update it
+  const auto cred = find_if(credentials.begin(), credentials.end(),
+                            [&ssid](const WifiCredential& cred) { return cred.ssid == ssid; });
+  if (cred != credentials.end()) {
+    cred->password = password;
+    Serial.printf("[%lu] [WCS] Updated credentials for: %s\n", millis(), ssid.c_str());
+    return saveToFile();
+  }
+
+  // Check if we've reached the limit
+  if (credentials.size() >= MAX_NETWORKS) {
+    Serial.printf("[%lu] [WCS] Cannot add more networks, limit of %zu reached\n", millis(), MAX_NETWORKS);
+    return false;
+  }
+
+  // Add new credential
+  credentials.push_back({ssid, password});
+  Serial.printf("[%lu] [WCS] Added credentials for: %s\n", millis(), ssid.c_str());
+  return saveToFile();
+}
+
+bool WifiCredentialStore::removeCredential(const std::string& ssid) {
+  const auto cred = find_if(credentials.begin(), credentials.end(),
+                            [&ssid](const WifiCredential& cred) { return cred.ssid == ssid; });
+  if (cred != credentials.end()) {
+    credentials.erase(cred);
+    Serial.printf("[%lu] [WCS] Removed credentials for: %s\n", millis(), ssid.c_str());
+    return saveToFile();
+  }
+  return false;  // Not found
+}
+
+const WifiCredential* WifiCredentialStore::findCredential(const std::string& ssid) const {
+  const auto cred = find_if(credentials.begin(), credentials.end(),
+                            [&ssid](const WifiCredential& cred) { return cred.ssid == ssid; });
+
+  if (cred != credentials.end()) {
+    return &*cred;
+  }
+
+  return nullptr;
+}
+
+bool WifiCredentialStore::hasSavedCredential(const std::string& ssid) const { return findCredential(ssid) != nullptr; }
+
+void WifiCredentialStore::clearAll() {
+  credentials.clear();
+  saveToFile();
+  Serial.printf("[%lu] [WCS] Cleared all WiFi credentials\n", millis());
+}

src/WifiCredentialStore.h

@@ -0,0 +1,56 @@
+#pragma once
+#include <string>
+#include <vector>
+
+struct WifiCredential {
+  std::string ssid;
+  std::string password;  // Stored obfuscated in file
+};
+
+/**
+ * Singleton class for storing WiFi credentials on the SD card.
+ * Credentials are stored in /sd/.crosspoint/wifi.bin with basic
+ * XOR obfuscation to prevent casual reading (not cryptographically secure).
+ */
+class WifiCredentialStore {
+ private:
+  static WifiCredentialStore instance;
+  std::vector<WifiCredential> credentials;
+
+  static constexpr size_t MAX_NETWORKS = 8;
+
+  // Private constructor for singleton
+  WifiCredentialStore() = default;
+
+  // XOR obfuscation (symmetric - same for encode/decode)
+  void obfuscate(std::string& data) const;
+
+ public:
+  // Delete copy constructor and assignment
+  WifiCredentialStore(const WifiCredentialStore&) = delete;
+  WifiCredentialStore& operator=(const WifiCredentialStore&) = delete;
+
+  // Get singleton instance
+  static WifiCredentialStore& getInstance() { return instance; }
+
+  // Save/load from SD card
+  bool saveToFile() const;
+  bool loadFromFile();
+
+  // Credential management
+  bool addCredential(const std::string& ssid, const std::string& password);
+  bool removeCredential(const std::string& ssid);
+  const WifiCredential* findCredential(const std::string& ssid) const;
+
+  // Get all stored credentials (for UI display)
+  const std::vector<WifiCredential>& getCredentials() const { return credentials; }
+
+  // Check if a network is saved
+  bool hasSavedCredential(const std::string& ssid) const;
+
+  // Clear all credentials
+  void clearAll();
+};
+
+// Helper macro to access credentials store
+#define WIFI_STORE WifiCredentialStore::getInstance()

src/activities/Activity.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <InputManager.h>
+
+class GfxRenderer;
+
+class Activity {
+ protected:
+  GfxRenderer& renderer;
+  InputManager& inputManager;
+
+ public:
+  explicit Activity(GfxRenderer& renderer, InputManager& inputManager)
+      : renderer(renderer), inputManager(inputManager) {}
+  virtual ~Activity() = default;
+  virtual void onEnter() {}
+  virtual void onExit() {}
+  virtual void loop() {}
+  virtual bool skipLoopDelay() { return false; }
+};

src/activities/ActivityWithSubactivity.cpp

@@ -0,0 +1,21 @@
+#include "ActivityWithSubactivity.h"
+
+void ActivityWithSubactivity::exitActivity() {
+  if (subActivity) {
+    subActivity->onExit();
+    subActivity.reset();
+  }
+}
+
+void ActivityWithSubactivity::enterNewActivity(Activity* activity) {
+  subActivity.reset(activity);
+  subActivity->onEnter();
+}
+
+void ActivityWithSubactivity::loop() {
+  if (subActivity) {
+    subActivity->loop();
+  }
+}
+
+void ActivityWithSubactivity::onExit() { exitActivity(); }

src/activities/ActivityWithSubactivity.h

@@ -0,0 +1,17 @@
+#pragma once
+#include <memory>
+
+#include "Activity.h"
+
+class ActivityWithSubactivity : public Activity {
+ protected:
+  std::unique_ptr<Activity> subActivity = nullptr;
+  void exitActivity();
+  void enterNewActivity(Activity* activity);
+
+ public:
+  explicit ActivityWithSubactivity(GfxRenderer& renderer, InputManager& inputManager)
+      : Activity(renderer, inputManager) {}
+  void loop() override;
+  void onExit() override;
+};

src/activities/boot_sleep/BootActivity.cpp

@@ -0,0 +1,18 @@
+#include "BootActivity.h"
+
+#include <GfxRenderer.h>
+
+#include "config.h"
+#include "images/CrossLarge.h"
+
+void BootActivity::onEnter() {
+  const auto pageWidth = GfxRenderer::getScreenWidth();
+  const auto pageHeight = GfxRenderer::getScreenHeight();
+
+  renderer.clearScreen();
+  renderer.drawImage(CrossLarge, (pageWidth - 128) / 2, (pageHeight - 128) / 2, 128, 128);
+  renderer.drawCenteredText(UI_FONT_ID, pageHeight / 2 + 70, "CrossPoint", true, BOLD);
+  renderer.drawCenteredText(SMALL_FONT_ID, pageHeight / 2 + 95, "BOOTING");
+  renderer.drawCenteredText(SMALL_FONT_ID, pageHeight - 30, CROSSPOINT_VERSION);
+  renderer.displayBuffer();
+}

src/activities/boot_sleep/BootActivity.h

@@ -0,0 +1,8 @@
+#pragma once
+#include "../Activity.h"
+
+class BootActivity final : public Activity {
+ public:
+  explicit BootActivity(GfxRenderer& renderer, InputManager& inputManager) : Activity(renderer, inputManager) {}
+  void onEnter() override;
+};

src/activities/boot_sleep/SleepActivity.cpp

@@ -0,0 +1,193 @@
+#include "SleepActivity.h"
+
+#include <Epub.h>
+#include <GfxRenderer.h>
+#include <SD.h>
+
+#include <vector>
+
+#include "CrossPointSettings.h"
+#include "CrossPointState.h"
+#include "config.h"
+#include "images/CrossLarge.h"
+
+void SleepActivity::onEnter() {
+  renderPopup("Entering Sleep...");
+
+  if (SETTINGS.sleepScreen == CrossPointSettings::SLEEP_SCREEN_MODE::CUSTOM) {
+    return renderCustomSleepScreen();
+  }
+
+  if (SETTINGS.sleepScreen == CrossPointSettings::SLEEP_SCREEN_MODE::COVER) {
+    return renderCoverSleepScreen();
+  }
+
+  renderDefaultSleepScreen();
+}
+
+void SleepActivity::renderPopup(const char* message) const {
+  const int textWidth = renderer.getTextWidth(READER_FONT_ID, message);
+  constexpr int margin = 20;
+  const int x = (renderer.getScreenWidth() - textWidth - margin * 2) / 2;
+  constexpr int y = 117;
+  const int w = textWidth + margin * 2;
+  const int h = renderer.getLineHeight(READER_FONT_ID) + margin * 2;
+  // renderer.clearScreen();
+  renderer.fillRect(x + 5, y + 5, w - 10, h - 10, false);
+  renderer.drawText(READER_FONT_ID, x + margin, y + margin, message);
+  renderer.drawRect(x + 5, y + 5, w - 10, h - 10);
+  renderer.displayBuffer();
+}
+
+void SleepActivity::renderCustomSleepScreen() const {
+  // Check if we have a /sleep directory
+  auto dir = SD.open("/sleep");
+  if (dir && dir.isDirectory()) {
+    std::vector<std::string> files;
+    // collect all valid BMP files
+    for (File file = dir.openNextFile(); file; file = dir.openNextFile()) {
+      if (file.isDirectory()) {
+        file.close();
+        continue;
+      }
+      auto filename = std::string(file.name());
+      if (filename[0] == '.') {
+        file.close();
+        continue;
+      }
+
+      if (filename.substr(filename.length() - 4) != ".bmp") {
+        Serial.printf("[%lu] [SLP] Skipping non-.bmp file name: %s\n", millis(), file.name());
+        file.close();
+        continue;
+      }
+      Bitmap bitmap(file);
+      if (bitmap.parseHeaders() != BmpReaderError::Ok) {
+        Serial.printf("[%lu] [SLP] Skipping invalid BMP file: %s\n", millis(), file.name());
+        file.close();
+        continue;
+      }
+      files.emplace_back(filename);
+      file.close();
+    }
+    const auto numFiles = files.size();
+    if (numFiles > 0) {
+      // Generate a random number between 1 and numFiles
+      const auto randomFileIndex = random(numFiles);
+      const auto filename = "/sleep/" + files[randomFileIndex];
+      auto file = SD.open(filename.c_str());
+      if (file) {
+        Serial.printf("[%lu] [SLP] Randomly loading: /sleep/%s\n", millis(), files[randomFileIndex].c_str());
+        delay(100);
+        Bitmap bitmap(file);
+        if (bitmap.parseHeaders() == BmpReaderError::Ok) {
+          renderBitmapSleepScreen(bitmap);
+          dir.close();
+          return;
+        }
+      }
+    }
+  }
+  if (dir) dir.close();
+
+  // Look for sleep.bmp on the root of the sd card to determine if we should
+  // render a custom sleep screen instead of the default.
+  auto file = SD.open("/sleep.bmp");
+  if (file) {
+    Bitmap bitmap(file);
+    if (bitmap.parseHeaders() == BmpReaderError::Ok) {
+      Serial.printf("[%lu] [SLP] Loading: /sleep.bmp\n", millis());
+      renderBitmapSleepScreen(bitmap);
+      return;
+    }
+  }
+
+  renderDefaultSleepScreen();
+}
+
+void SleepActivity::renderDefaultSleepScreen() const {
+  const auto pageWidth = renderer.getScreenWidth();
+  const auto pageHeight = renderer.getScreenHeight();
+
+  renderer.clearScreen();
+  renderer.drawImage(CrossLarge, (pageWidth - 128) / 2, (pageHeight - 128) / 2, 128, 128);
+  renderer.drawCenteredText(UI_FONT_ID, pageHeight / 2 + 70, "CrossPoint", true, BOLD);
+  renderer.drawCenteredText(SMALL_FONT_ID, pageHeight / 2 + 95, "SLEEPING");
+
+  // Make sleep screen dark unless light is selected in settings
+  if (SETTINGS.sleepScreen != CrossPointSettings::SLEEP_SCREEN_MODE::LIGHT) {
+    renderer.invertScreen();
+  }
+
+  renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
+}
+
+void SleepActivity::renderBitmapSleepScreen(const Bitmap& bitmap) const {
+  int x, y;
+  const auto pageWidth = renderer.getScreenWidth();
+  const auto pageHeight = renderer.getScreenHeight();
+
+  if (bitmap.getWidth() > pageWidth || bitmap.getHeight() > pageHeight) {
+    // image will scale, make sure placement is right
+    const float ratio = static_cast<float>(bitmap.getWidth()) / static_cast<float>(bitmap.getHeight());
+    const float screenRatio = static_cast<float>(pageWidth) / static_cast<float>(pageHeight);
+
+    if (ratio > screenRatio) {
+      // image wider than viewport ratio, scaled down image needs to be centered vertically
+      x = 0;
+      y = (pageHeight - pageWidth / ratio) / 2;
+    } else {
+      // image taller than viewport ratio, scaled down image needs to be centered horizontally
+      x = (pageWidth - pageHeight * ratio) / 2;
+      y = 0;
+    }
+  } else {
+    // center the image
+    x = (pageWidth - bitmap.getWidth()) / 2;
+    y = (pageHeight - bitmap.getHeight()) / 2;
+  }
+
+  renderer.clearScreen();
+  renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight);
+  renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
+
+  if (bitmap.hasGreyscale()) {
+    bitmap.rewindToData();
+    renderer.clearScreen(0x00);
+    renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB);
+    renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight);
+    renderer.copyGrayscaleLsbBuffers();
+
+    bitmap.rewindToData();
+    renderer.clearScreen(0x00);
+    renderer.setRenderMode(GfxRenderer::GRAYSCALE_MSB);
+    renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight);
+    renderer.copyGrayscaleMsbBuffers();
+
+    renderer.displayGrayBuffer();
+    renderer.setRenderMode(GfxRenderer::BW);
+  }
+}
+
+void SleepActivity::renderCoverSleepScreen() const {
+  Epub lastEpub(APP_STATE.openEpubPath, "/.crosspoint");
+  if (!lastEpub.load()) {
+    Serial.println("[SLP] Failed to load last epub");
+    return renderDefaultSleepScreen();
+  }
+  if (!lastEpub.generateCoverBmp()) {
+    Serial.println("[SLP] Failed to generate cover bmp");
+    return renderDefaultSleepScreen();
+  }
+
+  auto file = SD.open(lastEpub.getCoverBmpPath().c_str(), FILE_READ);
+  if (file) {
+    Bitmap bitmap(file);
+    if (bitmap.parseHeaders() == BmpReaderError::Ok) {
+      renderBitmapSleepScreen(bitmap);
+      return;
+    }
+  }
+
+  renderDefaultSleepScreen();
+}

src/activities/boot_sleep/SleepActivity.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "../Activity.h"
+
+class Bitmap;
+
+class SleepActivity final : public Activity {
+ public:
+  explicit SleepActivity(GfxRenderer& renderer, InputManager& inputManager) : Activity(renderer, inputManager) {}
+  void onEnter() override;
+
+ private:
+  void renderPopup(const char* message) const;
+  void renderDefaultSleepScreen() const;
+  void renderCustomSleepScreen() const;
+  void renderCoverSleepScreen() const;
+  void renderBitmapSleepScreen(const Bitmap& bitmap) const;
+};

src/activities/home/HomeActivity.cpp

@@ -0,0 +1,106 @@
+#include "HomeActivity.h"
+
+#include <GfxRenderer.h>
+#include <SD.h>
+
+#include "config.h"
+
+namespace {
+constexpr int menuItemCount = 3;
+}
+
+void HomeActivity::taskTrampoline(void* param) {
+  auto* self = static_cast<HomeActivity*>(param);
+  self->displayTaskLoop();
+}
+
+void HomeActivity::onEnter() {
+  renderingMutex = xSemaphoreCreateMutex();
+
+  selectorIndex = 0;
+
+  // Trigger first update
+  updateRequired = true;
+
+  xTaskCreate(&HomeActivity::taskTrampoline, "HomeActivityTask",
+              2048,               // Stack size
+              this,               // Parameters
+              1,                  // Priority
+              &displayTaskHandle  // Task handle
+  );
+}
+
+void HomeActivity::onExit() {
+  // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+  }
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+}
+
+void HomeActivity::loop() {
+  const bool prevPressed =
+      inputManager.wasPressed(InputManager::BTN_UP) || inputManager.wasPressed(InputManager::BTN_LEFT);
+  const bool nextPressed =
+      inputManager.wasPressed(InputManager::BTN_DOWN) || inputManager.wasPressed(InputManager::BTN_RIGHT);
+
+  if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
+    if (selectorIndex == 0) {
+      onReaderOpen();
+    } else if (selectorIndex == 1) {
+      onFileTransferOpen();
+    } else if (selectorIndex == 2) {
+      onSettingsOpen();
+    }
+  } else if (prevPressed) {
+    selectorIndex = (selectorIndex + menuItemCount - 1) % menuItemCount;
+    updateRequired = true;
+  } else if (nextPressed) {
+    selectorIndex = (selectorIndex + 1) % menuItemCount;
+    updateRequired = true;
+  }
+}
+
+void HomeActivity::displayTaskLoop() {
+  while (true) {
+    if (updateRequired) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      render();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+void HomeActivity::render() const {
+  renderer.clearScreen();
+
+  const auto pageWidth = GfxRenderer::getScreenWidth();
+  const auto pageHeight = GfxRenderer::getScreenHeight();
+  renderer.drawCenteredText(READER_FONT_ID, 10, "CrossPoint Reader", true, BOLD);
+
+  // Draw selection
+  renderer.fillRect(0, 60 + selectorIndex * 30 + 2, pageWidth - 1, 30);
+  renderer.drawText(UI_FONT_ID, 20, 60, "Read", selectorIndex != 0);
+  renderer.drawText(UI_FONT_ID, 20, 90, "File transfer", selectorIndex != 1);
+  renderer.drawText(UI_FONT_ID, 20, 120, "Settings", selectorIndex != 2);
+
+  renderer.drawRect(25, pageHeight - 40, 106, 40);
+  renderer.drawText(UI_FONT_ID, 25 + (105 - renderer.getTextWidth(UI_FONT_ID, "Back")) / 2, pageHeight - 35, "Back");
+
+  renderer.drawRect(130, pageHeight - 40, 106, 40);
+  renderer.drawText(UI_FONT_ID, 130 + (105 - renderer.getTextWidth(UI_FONT_ID, "Confirm")) / 2, pageHeight - 35,
+                    "Confirm");
+
+  renderer.drawRect(245, pageHeight - 40, 106, 40);
+  renderer.drawText(UI_FONT_ID, 245 + (105 - renderer.getTextWidth(UI_FONT_ID, "Left")) / 2, pageHeight - 35, "Left");
+
+  renderer.drawRect(350, pageHeight - 40, 106, 40);
+  renderer.drawText(UI_FONT_ID, 350 + (105 - renderer.getTextWidth(UI_FONT_ID, "Right")) / 2, pageHeight - 35, "Right");
+
+  renderer.displayBuffer();
+}

src/activities/home/HomeActivity.h

@@ -0,0 +1,33 @@
+#pragma once
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <functional>
+
+#include "../Activity.h"
+
+class HomeActivity final : public Activity {
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  int selectorIndex = 0;
+  bool updateRequired = false;
+  const std::function<void()> onReaderOpen;
+  const std::function<void()> onSettingsOpen;
+  const std::function<void()> onFileTransferOpen;
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void render() const;
+
+ public:
+  explicit HomeActivity(GfxRenderer& renderer, InputManager& inputManager, const std::function<void()>& onReaderOpen,
+                        const std::function<void()>& onSettingsOpen, const std::function<void()>& onFileTransferOpen)
+      : Activity(renderer, inputManager),
+        onReaderOpen(onReaderOpen),
+        onSettingsOpen(onSettingsOpen),
+        onFileTransferOpen(onFileTransferOpen) {}
+  void onEnter() override;
+  void onExit() override;
+  void loop() override;
+};

src/activities/network/CrossPointWebServerActivity.cpp

@@ -0,0 +1,242 @@
+#include "CrossPointWebServerActivity.h"
+
+#include <GfxRenderer.h>
+#include <WiFi.h>
+
+#include "config.h"
+
+void CrossPointWebServerActivity::taskTrampoline(void* param) {
+  auto* self = static_cast<CrossPointWebServerActivity*>(param);
+  self->displayTaskLoop();
+}
+
+void CrossPointWebServerActivity::onEnter() {
+  Serial.printf("[%lu] [WEBACT] ========== CrossPointWebServerActivity onEnter ==========\n", millis());
+  Serial.printf("[%lu] [WEBACT] [MEM] Free heap at onEnter: %d bytes\n", millis(), ESP.getFreeHeap());
+
+  renderingMutex = xSemaphoreCreateMutex();
+
+  // Reset state
+  state = WebServerActivityState::WIFI_SELECTION;
+  connectedIP.clear();
+  connectedSSID.clear();
+  lastHandleClientTime = 0;
+  updateRequired = true;
+
+  xTaskCreate(&CrossPointWebServerActivity::taskTrampoline, "WebServerActivityTask",
+              2048,               // Stack size
+              this,               // Parameters
+              1,                  // Priority
+              &displayTaskHandle  // Task handle
+  );
+
+  // Turn on WiFi immediately
+  Serial.printf("[%lu] [WEBACT] Turning on WiFi...\n", millis());
+  WiFi.mode(WIFI_STA);
+
+  // Launch WiFi selection subactivity
+  Serial.printf("[%lu] [WEBACT] Launching WifiSelectionActivity...\n", millis());
+  wifiSelection.reset(new WifiSelectionActivity(renderer, inputManager,
+                                                [this](bool connected) { onWifiSelectionComplete(connected); }));
+  wifiSelection->onEnter();
+}
+
+void CrossPointWebServerActivity::onExit() {
+  Serial.printf("[%lu] [WEBACT] ========== CrossPointWebServerActivity onExit START ==========\n", millis());
+  Serial.printf("[%lu] [WEBACT] [MEM] Free heap at onExit start: %d bytes\n", millis(), ESP.getFreeHeap());
+
+  state = WebServerActivityState::SHUTTING_DOWN;
+
+  // Stop the web server first (before disconnecting WiFi)
+  stopWebServer();
+
+  // Exit WiFi selection subactivity if still active
+  if (wifiSelection) {
+    Serial.printf("[%lu] [WEBACT] Exiting WifiSelectionActivity...\n", millis());
+    wifiSelection->onExit();
+    wifiSelection.reset();
+    Serial.printf("[%lu] [WEBACT] WifiSelectionActivity exited\n", millis());
+  }
+
+  // CRITICAL: Wait for LWIP stack to flush any pending packets
+  Serial.printf("[%lu] [WEBACT] Waiting 500ms for network stack to flush pending packets...\n", millis());
+  delay(500);
+
+  // Disconnect WiFi gracefully
+  Serial.printf("[%lu] [WEBACT] Disconnecting WiFi (graceful)...\n", millis());
+  WiFi.disconnect(false);  // false = don't erase credentials, send disconnect frame
+  delay(100);              // Allow disconnect frame to be sent
+
+  Serial.printf("[%lu] [WEBACT] Setting WiFi mode OFF...\n", millis());
+  WiFi.mode(WIFI_OFF);
+  delay(100);  // Allow WiFi hardware to fully power down
+
+  Serial.printf("[%lu] [WEBACT] [MEM] Free heap after WiFi disconnect: %d bytes\n", millis(), ESP.getFreeHeap());
+
+  // Acquire mutex before deleting task
+  Serial.printf("[%lu] [WEBACT] Acquiring rendering mutex before task deletion...\n", millis());
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+
+  // Delete the display task
+  Serial.printf("[%lu] [WEBACT] Deleting display task...\n", millis());
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+    Serial.printf("[%lu] [WEBACT] Display task deleted\n", millis());
+  }
+
+  // Delete the mutex
+  Serial.printf("[%lu] [WEBACT] Deleting mutex...\n", millis());
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+  Serial.printf("[%lu] [WEBACT] Mutex deleted\n", millis());
+
+  Serial.printf("[%lu] [WEBACT] [MEM] Free heap at onExit end: %d bytes\n", millis(), ESP.getFreeHeap());
+  Serial.printf("[%lu] [WEBACT] ========== CrossPointWebServerActivity onExit COMPLETE ==========\n", millis());
+}
+
+void CrossPointWebServerActivity::onWifiSelectionComplete(bool connected) {
+  Serial.printf("[%lu] [WEBACT] WifiSelectionActivity completed, connected=%d\n", millis(), connected);
+
+  if (connected) {
+    // Get connection info before exiting subactivity
+    connectedIP = wifiSelection->getConnectedIP();
+    connectedSSID = WiFi.SSID().c_str();
+
+    // Exit the wifi selection subactivity
+    wifiSelection->onExit();
+    wifiSelection.reset();
+
+    // Start the web server
+    startWebServer();
+  } else {
+    // User cancelled - go back
+    onGoBack();
+  }
+}
+
+void CrossPointWebServerActivity::startWebServer() {
+  Serial.printf("[%lu] [WEBACT] Starting web server...\n", millis());
+
+  // Create the web server instance
+  webServer.reset(new CrossPointWebServer());
+  webServer->begin();
+
+  if (webServer->isRunning()) {
+    state = WebServerActivityState::SERVER_RUNNING;
+    Serial.printf("[%lu] [WEBACT] Web server started successfully\n", millis());
+
+    // Force an immediate render since we're transitioning from a subactivity
+    // that had its own rendering task. We need to make sure our display is shown.
+    xSemaphoreTake(renderingMutex, portMAX_DELAY);
+    render();
+    xSemaphoreGive(renderingMutex);
+    Serial.printf("[%lu] [WEBACT] Rendered File Transfer screen\n", millis());
+  } else {
+    Serial.printf("[%lu] [WEBACT] ERROR: Failed to start web server!\n", millis());
+    webServer.reset();
+    // Go back on error
+    onGoBack();
+  }
+}
+
+void CrossPointWebServerActivity::stopWebServer() {
+  if (webServer && webServer->isRunning()) {
+    Serial.printf("[%lu] [WEBACT] Stopping web server...\n", millis());
+    webServer->stop();
+    Serial.printf("[%lu] [WEBACT] Web server stopped\n", millis());
+  }
+  webServer.reset();
+}
+
+void CrossPointWebServerActivity::loop() {
+  // Handle different states
+  switch (state) {
+    case WebServerActivityState::WIFI_SELECTION:
+      // Forward loop to WiFi selection subactivity
+      if (wifiSelection) {
+        wifiSelection->loop();
+      }
+      break;
+
+    case WebServerActivityState::SERVER_RUNNING:
+      // Handle web server requests - call handleClient multiple times per loop
+      // to improve responsiveness and upload throughput
+      if (webServer && webServer->isRunning()) {
+        unsigned long timeSinceLastHandleClient = millis() - lastHandleClientTime;
+
+        // Log if there's a significant gap between handleClient calls (>100ms)
+        if (lastHandleClientTime > 0 && timeSinceLastHandleClient > 100) {
+          Serial.printf("[%lu] [WEBACT] WARNING: %lu ms gap since last handleClient\n", millis(),
+                        timeSinceLastHandleClient);
+        }
+
+        // Call handleClient multiple times to process pending requests faster
+        // This is critical for upload performance - HTTP file uploads send data
+        // in chunks and each handleClient() call processes incoming data
+        constexpr int HANDLE_CLIENT_ITERATIONS = 10;
+        for (int i = 0; i < HANDLE_CLIENT_ITERATIONS && webServer->isRunning(); i++) {
+          webServer->handleClient();
+        }
+        lastHandleClientTime = millis();
+      }
+
+      // Handle exit on Back button
+      if (inputManager.wasPressed(InputManager::BTN_BACK)) {
+        onGoBack();
+        return;
+      }
+      break;
+
+    case WebServerActivityState::SHUTTING_DOWN:
+      // Do nothing - waiting for cleanup
+      break;
+  }
+}
+
+void CrossPointWebServerActivity::displayTaskLoop() {
+  while (true) {
+    if (updateRequired) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      render();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+void CrossPointWebServerActivity::render() const {
+  // Only render our own UI when server is running
+  // WiFi selection handles its own rendering
+  if (state == WebServerActivityState::SERVER_RUNNING) {
+    renderer.clearScreen();
+    renderServerRunning();
+    renderer.displayBuffer();
+  }
+}
+
+void CrossPointWebServerActivity::renderServerRunning() const {
+  const auto pageHeight = renderer.getScreenHeight();
+  const auto height = renderer.getLineHeight(UI_FONT_ID);
+  const auto top = (pageHeight - height * 5) / 2;
+
+  renderer.drawCenteredText(READER_FONT_ID, top - 30, "File Transfer", true, BOLD);
+
+  std::string ssidInfo = "Network: " + connectedSSID;
+  if (ssidInfo.length() > 28) {
+    ssidInfo.replace(25, ssidInfo.length() - 25, "...");
+  }
+  renderer.drawCenteredText(UI_FONT_ID, top + 10, ssidInfo.c_str(), true, REGULAR);
+
+  std::string ipInfo = "IP Address: " + connectedIP;
+  renderer.drawCenteredText(UI_FONT_ID, top + 40, ipInfo.c_str(), true, REGULAR);
+
+  // Show web server URL prominently
+  std::string webInfo = "http://" + connectedIP + "/";
+  renderer.drawCenteredText(UI_FONT_ID, top + 70, webInfo.c_str(), true, BOLD);
+
+  renderer.drawCenteredText(SMALL_FONT_ID, top + 110, "Open this URL in your browser", true, REGULAR);
+
+  renderer.drawCenteredText(SMALL_FONT_ID, pageHeight - 30, "Press BACK to exit", true, REGULAR);
+}

src/activities/network/CrossPointWebServerActivity.h

@@ -0,0 +1,66 @@
+#pragma once
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+
+#include "../Activity.h"
+#include "WifiSelectionActivity.h"
+#include "server/CrossPointWebServer.h"
+
+// Web server activity states
+enum class WebServerActivityState {
+  WIFI_SELECTION,  // WiFi selection subactivity is active
+  SERVER_RUNNING,  // Web server is running and handling requests
+  SHUTTING_DOWN    // Shutting down server and WiFi
+};
+
+/**
+ * CrossPointWebServerActivity is the entry point for file transfer functionality.
+ * It:
+ * - Immediately turns on WiFi and launches WifiSelectionActivity on enter
+ * - When WifiSelectionActivity completes successfully, starts the CrossPointWebServer
+ * - Handles client requests in its loop() function
+ * - Cleans up the server and shuts down WiFi on exit
+ */
+class CrossPointWebServerActivity final : public Activity {
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  bool updateRequired = false;
+  WebServerActivityState state = WebServerActivityState::WIFI_SELECTION;
+  const std::function<void()> onGoBack;
+
+  // WiFi selection subactivity
+  std::unique_ptr<WifiSelectionActivity> wifiSelection;
+
+  // Web server - owned by this activity
+  std::unique_ptr<CrossPointWebServer> webServer;
+
+  // Server status
+  std::string connectedIP;
+  std::string connectedSSID;
+
+  // Performance monitoring
+  unsigned long lastHandleClientTime = 0;
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void render() const;
+  void renderServerRunning() const;
+
+  void onWifiSelectionComplete(bool connected);
+  void startWebServer();
+  void stopWebServer();
+
+ public:
+  explicit CrossPointWebServerActivity(GfxRenderer& renderer, InputManager& inputManager,
+                                       const std::function<void()>& onGoBack)
+      : Activity(renderer, inputManager), onGoBack(onGoBack) {}
+  void onEnter() override;
+  void onExit() override;
+  void loop() override;
+  bool skipLoopDelay() override { return webServer && webServer->isRunning(); }
+};

src/activities/network/WifiSelectionActivity.cpp

@@ -0,0 +1,688 @@
+#include "WifiSelectionActivity.h"
+
+#include <GfxRenderer.h>
+#include <WiFi.h>
+
+#include <map>
+
+#include "WifiCredentialStore.h"
+#include "config.h"
+
+void WifiSelectionActivity::taskTrampoline(void* param) {
+  auto* self = static_cast<WifiSelectionActivity*>(param);
+  self->displayTaskLoop();
+}
+
+void WifiSelectionActivity::onEnter() {
+  renderingMutex = xSemaphoreCreateMutex();
+
+  // Load saved WiFi credentials
+  WIFI_STORE.loadFromFile();
+
+  // Reset state
+  selectedNetworkIndex = 0;
+  networks.clear();
+  state = WifiSelectionState::SCANNING;
+  selectedSSID.clear();
+  connectedIP.clear();
+  connectionError.clear();
+  enteredPassword.clear();
+  usedSavedPassword = false;
+  savePromptSelection = 0;
+  forgetPromptSelection = 0;
+  keyboard.reset();
+
+  // Trigger first update to show scanning message
+  updateRequired = true;
+
+  xTaskCreate(&WifiSelectionActivity::taskTrampoline, "WifiSelectionTask",
+              4096,               // Stack size (larger for WiFi operations)
+              this,               // Parameters
+              1,                  // Priority
+              &displayTaskHandle  // Task handle
+  );
+
+  // Start WiFi scan
+  startWifiScan();
+}
+
+void WifiSelectionActivity::onExit() {
+  Serial.printf("[%lu] [WIFI] ========== WifiSelectionActivity onExit START ==========\n", millis());
+  Serial.printf("[%lu] [WIFI] [MEM] Free heap at onExit start: %d bytes\n", millis(), ESP.getFreeHeap());
+
+  // Stop any ongoing WiFi scan
+  Serial.printf("[%lu] [WIFI] Deleting WiFi scan...\n", millis());
+  WiFi.scanDelete();
+  Serial.printf("[%lu] [WIFI] [MEM] Free heap after scanDelete: %d bytes\n", millis(), ESP.getFreeHeap());
+
+  // Note: We do NOT disconnect WiFi here - the parent activity (CrossPointWebServerActivity)
+  // manages WiFi connection state. We just clean up the scan and task.
+
+  // Acquire mutex before deleting task to ensure task isn't using it
+  // This prevents hangs/crashes if the task holds the mutex when deleted
+  Serial.printf("[%lu] [WIFI] Acquiring rendering mutex before task deletion...\n", millis());
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+
+  // Delete the display task (we now hold the mutex, so task is blocked if it needs it)
+  Serial.printf("[%lu] [WIFI] Deleting display task...\n", millis());
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+    Serial.printf("[%lu] [WIFI] Display task deleted\n", millis());
+  }
+
+  // Now safe to delete the mutex since we own it
+  Serial.printf("[%lu] [WIFI] Deleting mutex...\n", millis());
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+  Serial.printf("[%lu] [WIFI] Mutex deleted\n", millis());
+
+  Serial.printf("[%lu] [WIFI] [MEM] Free heap at onExit end: %d bytes\n", millis(), ESP.getFreeHeap());
+  Serial.printf("[%lu] [WIFI] ========== WifiSelectionActivity onExit COMPLETE ==========\n", millis());
+}
+
+void WifiSelectionActivity::startWifiScan() {
+  state = WifiSelectionState::SCANNING;
+  networks.clear();
+  updateRequired = true;
+
+  // Set WiFi mode to station
+  WiFi.mode(WIFI_STA);
+  WiFi.disconnect();
+  delay(100);
+
+  // Start async scan
+  WiFi.scanNetworks(true);  // true = async scan
+}
+
+void WifiSelectionActivity::processWifiScanResults() {
+  int16_t scanResult = WiFi.scanComplete();
+
+  if (scanResult == WIFI_SCAN_RUNNING) {
+    // Scan still in progress
+    return;
+  }
+
+  if (scanResult == WIFI_SCAN_FAILED) {
+    state = WifiSelectionState::NETWORK_LIST;
+    updateRequired = true;
+    return;
+  }
+
+  // Scan complete, process results
+  // Use a map to deduplicate networks by SSID, keeping the strongest signal
+  std::map<std::string, WifiNetworkInfo> uniqueNetworks;
+
+  for (int i = 0; i < scanResult; i++) {
+    std::string ssid = WiFi.SSID(i).c_str();
+    int32_t rssi = WiFi.RSSI(i);
+
+    // Skip hidden networks (empty SSID)
+    if (ssid.empty()) {
+      continue;
+    }
+
+    // Check if we've already seen this SSID
+    auto it = uniqueNetworks.find(ssid);
+    if (it == uniqueNetworks.end() || rssi > it->second.rssi) {
+      // New network or stronger signal than existing entry
+      WifiNetworkInfo network;
+      network.ssid = ssid;
+      network.rssi = rssi;
+      network.isEncrypted = (WiFi.encryptionType(i) != WIFI_AUTH_OPEN);
+      network.hasSavedPassword = WIFI_STORE.hasSavedCredential(network.ssid);
+      uniqueNetworks[ssid] = network;
+    }
+  }
+
+  // Convert map to vector
+  networks.clear();
+  for (const auto& pair : uniqueNetworks) {
+    // cppcheck-suppress useStlAlgorithm
+    networks.push_back(pair.second);
+  }
+
+  // Sort by signal strength (strongest first)
+  std::sort(networks.begin(), networks.end(),
+            [](const WifiNetworkInfo& a, const WifiNetworkInfo& b) { return a.rssi > b.rssi; });
+
+  WiFi.scanDelete();
+  state = WifiSelectionState::NETWORK_LIST;
+  selectedNetworkIndex = 0;
+  updateRequired = true;
+}
+
+void WifiSelectionActivity::selectNetwork(int index) {
+  if (index < 0 || index >= static_cast<int>(networks.size())) {
+    return;
+  }
+
+  const auto& network = networks[index];
+  selectedSSID = network.ssid;
+  selectedRequiresPassword = network.isEncrypted;
+  usedSavedPassword = false;
+  enteredPassword.clear();
+
+  // Check if we have saved credentials for this network
+  const auto* savedCred = WIFI_STORE.findCredential(selectedSSID);
+  if (savedCred && !savedCred->password.empty()) {
+    // Use saved password - connect directly
+    enteredPassword = savedCred->password;
+    usedSavedPassword = true;
+    Serial.printf("[%lu] [WiFi] Using saved password for %s, length: %zu\n", millis(), selectedSSID.c_str(),
+                  enteredPassword.size());
+    attemptConnection();
+    return;
+  }
+
+  if (selectedRequiresPassword) {
+    // Show password entry
+    state = WifiSelectionState::PASSWORD_ENTRY;
+    keyboard.reset(new KeyboardEntryActivity(renderer, inputManager, "Enter WiFi Password",
+                                             "",    // No initial text
+                                             64,    // Max password length
+                                             false  // Show password by default (hard keyboard to use)
+                                             ));
+    updateRequired = true;
+  } else {
+    // Connect directly for open networks
+    attemptConnection();
+  }
+}
+
+void WifiSelectionActivity::attemptConnection() {
+  state = WifiSelectionState::CONNECTING;
+  connectionStartTime = millis();
+  connectedIP.clear();
+  connectionError.clear();
+  updateRequired = true;
+
+  WiFi.mode(WIFI_STA);
+
+  // Get password from keyboard if we just entered it
+  if (keyboard && !usedSavedPassword) {
+    enteredPassword = keyboard->getText();
+  }
+
+  if (selectedRequiresPassword && !enteredPassword.empty()) {
+    WiFi.begin(selectedSSID.c_str(), enteredPassword.c_str());
+  } else {
+    WiFi.begin(selectedSSID.c_str());
+  }
+}
+
+void WifiSelectionActivity::checkConnectionStatus() {
+  if (state != WifiSelectionState::CONNECTING) {
+    return;
+  }
+
+  wl_status_t status = WiFi.status();
+
+  if (status == WL_CONNECTED) {
+    // Successfully connected
+    IPAddress ip = WiFi.localIP();
+    char ipStr[16];
+    snprintf(ipStr, sizeof(ipStr), "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
+    connectedIP = ipStr;
+
+    // If we entered a new password, ask if user wants to save it
+    // Otherwise, immediately complete so parent can start web server
+    if (!usedSavedPassword && !enteredPassword.empty()) {
+      state = WifiSelectionState::SAVE_PROMPT;
+      savePromptSelection = 0;  // Default to "Yes"
+      updateRequired = true;
+    } else {
+      // Using saved password or open network - complete immediately
+      Serial.printf("[%lu] [WIFI] Connected with saved/open credentials, completing immediately\n", millis());
+      onComplete(true);
+    }
+    return;
+  }
+
+  if (status == WL_CONNECT_FAILED || status == WL_NO_SSID_AVAIL) {
+    connectionError = "Connection failed";
+    if (status == WL_NO_SSID_AVAIL) {
+      connectionError = "Network not found";
+    }
+    state = WifiSelectionState::CONNECTION_FAILED;
+    updateRequired = true;
+    return;
+  }
+
+  // Check for timeout
+  if (millis() - connectionStartTime > CONNECTION_TIMEOUT_MS) {
+    WiFi.disconnect();
+    connectionError = "Connection timeout";
+    state = WifiSelectionState::CONNECTION_FAILED;
+    updateRequired = true;
+    return;
+  }
+}
+
+void WifiSelectionActivity::loop() {
+  // Check scan progress
+  if (state == WifiSelectionState::SCANNING) {
+    processWifiScanResults();
+    return;
+  }
+
+  // Check connection progress
+  if (state == WifiSelectionState::CONNECTING) {
+    checkConnectionStatus();
+    return;
+  }
+
+  // Handle password entry state
+  if (state == WifiSelectionState::PASSWORD_ENTRY && keyboard) {
+    keyboard->handleInput();
+
+    if (keyboard->isComplete()) {
+      attemptConnection();
+      return;
+    }
+
+    if (keyboard->isCancelled()) {
+      state = WifiSelectionState::NETWORK_LIST;
+      keyboard.reset();
+      updateRequired = true;
+      return;
+    }
+
+    updateRequired = true;
+    return;
+  }
+
+  // Handle save prompt state
+  if (state == WifiSelectionState::SAVE_PROMPT) {
+    if (inputManager.wasPressed(InputManager::BTN_LEFT) || inputManager.wasPressed(InputManager::BTN_UP)) {
+      if (savePromptSelection > 0) {
+        savePromptSelection--;
+        updateRequired = true;
+      }
+    } else if (inputManager.wasPressed(InputManager::BTN_RIGHT) || inputManager.wasPressed(InputManager::BTN_DOWN)) {
+      if (savePromptSelection < 1) {
+        savePromptSelection++;
+        updateRequired = true;
+      }
+    } else if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
+      if (savePromptSelection == 0) {
+        // User chose "Yes" - save the password
+        WIFI_STORE.addCredential(selectedSSID, enteredPassword);
+      }
+      // Complete - parent will start web server
+      onComplete(true);
+    } else if (inputManager.wasPressed(InputManager::BTN_BACK)) {
+      // Skip saving, complete anyway
+      onComplete(true);
+    }
+    return;
+  }
+
+  // Handle forget prompt state (connection failed with saved credentials)
+  if (state == WifiSelectionState::FORGET_PROMPT) {
+    if (inputManager.wasPressed(InputManager::BTN_LEFT) || inputManager.wasPressed(InputManager::BTN_UP)) {
+      if (forgetPromptSelection > 0) {
+        forgetPromptSelection--;
+        updateRequired = true;
+      }
+    } else if (inputManager.wasPressed(InputManager::BTN_RIGHT) || inputManager.wasPressed(InputManager::BTN_DOWN)) {
+      if (forgetPromptSelection < 1) {
+        forgetPromptSelection++;
+        updateRequired = true;
+      }
+    } else if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
+      if (forgetPromptSelection == 0) {
+        // User chose "Yes" - forget the network
+        WIFI_STORE.removeCredential(selectedSSID);
+        // Update the network list to reflect the change
+        const auto network = find_if(networks.begin(), networks.end(),
+                                     [this](const WifiNetworkInfo& net) { return net.ssid == selectedSSID; });
+        if (network != networks.end()) {
+          network->hasSavedPassword = false;
+        }
+      }
+      // Go back to network list
+      state = WifiSelectionState::NETWORK_LIST;
+      updateRequired = true;
+    } else if (inputManager.wasPressed(InputManager::BTN_BACK)) {
+      // Skip forgetting, go back to network list
+      state = WifiSelectionState::NETWORK_LIST;
+      updateRequired = true;
+    }
+    return;
+  }
+
+  // Handle connected state (should not normally be reached - connection completes immediately)
+  if (state == WifiSelectionState::CONNECTED) {
+    // Safety fallback - immediately complete
+    onComplete(true);
+    return;
+  }
+
+  // Handle connection failed state
+  if (state == WifiSelectionState::CONNECTION_FAILED) {
+    if (inputManager.wasPressed(InputManager::BTN_BACK) || inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
+      // If we used saved credentials, offer to forget the network
+      if (usedSavedPassword) {
+        state = WifiSelectionState::FORGET_PROMPT;
+        forgetPromptSelection = 0;  // Default to "Yes"
+      } else {
+        // Go back to network list on failure
+        state = WifiSelectionState::NETWORK_LIST;
+      }
+      updateRequired = true;
+      return;
+    }
+  }
+
+  // Handle network list state
+  if (state == WifiSelectionState::NETWORK_LIST) {
+    // Check for Back button to exit (cancel)
+    if (inputManager.wasPressed(InputManager::BTN_BACK)) {
+      onComplete(false);
+      return;
+    }
+
+    // Check for Confirm button to select network or rescan
+    if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
+      if (!networks.empty()) {
+        selectNetwork(selectedNetworkIndex);
+      } else {
+        startWifiScan();
+      }
+      return;
+    }
+
+    // Handle UP/DOWN navigation
+    if (inputManager.wasPressed(InputManager::BTN_UP) || inputManager.wasPressed(InputManager::BTN_LEFT)) {
+      if (selectedNetworkIndex > 0) {
+        selectedNetworkIndex--;
+        updateRequired = true;
+      }
+    } else if (inputManager.wasPressed(InputManager::BTN_DOWN) || inputManager.wasPressed(InputManager::BTN_RIGHT)) {
+      if (!networks.empty() && selectedNetworkIndex < static_cast<int>(networks.size()) - 1) {
+        selectedNetworkIndex++;
+        updateRequired = true;
+      }
+    }
+  }
+}
+
+std::string WifiSelectionActivity::getSignalStrengthIndicator(int32_t rssi) const {
+  // Convert RSSI to signal bars representation
+  if (rssi >= -50) {
+    return "||||";  // Excellent
+  } else if (rssi >= -60) {
+    return "||| ";  // Good
+  } else if (rssi >= -70) {
+    return "||  ";  // Fair
+  } else if (rssi >= -80) {
+    return "|   ";  // Weak
+  }
+  return "    ";  // Very weak
+}
+
+void WifiSelectionActivity::displayTaskLoop() {
+  while (true) {
+    if (updateRequired) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      render();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+void WifiSelectionActivity::render() const {
+  renderer.clearScreen();
+
+  switch (state) {
+    case WifiSelectionState::SCANNING:
+      renderConnecting();  // Reuse connecting screen with different message
+      break;
+    case WifiSelectionState::NETWORK_LIST:
+      renderNetworkList();
+      break;
+    case WifiSelectionState::PASSWORD_ENTRY:
+      renderPasswordEntry();
+      break;
+    case WifiSelectionState::CONNECTING:
+      renderConnecting();
+      break;
+    case WifiSelectionState::CONNECTED:
+      renderConnected();
+      break;
+    case WifiSelectionState::SAVE_PROMPT:
+      renderSavePrompt();
+      break;
+    case WifiSelectionState::CONNECTION_FAILED:
+      renderConnectionFailed();
+      break;
+    case WifiSelectionState::FORGET_PROMPT:
+      renderForgetPrompt();
+      break;
+  }
+
+  renderer.displayBuffer();
+}
+
+void WifiSelectionActivity::renderNetworkList() const {
+  const auto pageWidth = renderer.getScreenWidth();
+  const auto pageHeight = renderer.getScreenHeight();
+
+  // Draw header
+  renderer.drawCenteredText(READER_FONT_ID, 10, "WiFi Networks", true, BOLD);
+
+  if (networks.empty()) {
+    // No networks found or scan failed
+    const auto height = renderer.getLineHeight(UI_FONT_ID);
+    const auto top = (pageHeight - height) / 2;
+    renderer.drawCenteredText(UI_FONT_ID, top, "No networks found", true, REGULAR);
+    renderer.drawCenteredText(SMALL_FONT_ID, top + height + 10, "Press OK to scan again", true, REGULAR);
+  } else {
+    // Calculate how many networks we can display
+    const int startY = 60;
+    const int lineHeight = 25;
+    const int maxVisibleNetworks = (pageHeight - startY - 40) / lineHeight;
+
+    // Calculate scroll offset to keep selected item visible
+    int scrollOffset = 0;
+    if (selectedNetworkIndex >= maxVisibleNetworks) {
+      scrollOffset = selectedNetworkIndex - maxVisibleNetworks + 1;
+    }
+
+    // Draw networks
+    int displayIndex = 0;
+    for (size_t i = scrollOffset; i < networks.size() && displayIndex < maxVisibleNetworks; i++, displayIndex++) {
+      const int networkY = startY + displayIndex * lineHeight;
+      const auto& network = networks[i];
+
+      // Draw selection indicator
+      if (static_cast<int>(i) == selectedNetworkIndex) {
+        renderer.drawText(UI_FONT_ID, 5, networkY, ">");
+      }
+
+      // Draw network name (truncate if too long)
+      std::string displayName = network.ssid;
+      if (displayName.length() > 16) {
+        displayName.replace(13, displayName.length() - 13, "...");
+      }
+      renderer.drawText(UI_FONT_ID, 20, networkY, displayName.c_str());
+
+      // Draw signal strength indicator
+      std::string signalStr = getSignalStrengthIndicator(network.rssi);
+      renderer.drawText(UI_FONT_ID, pageWidth - 90, networkY, signalStr.c_str());
+
+      // Draw saved indicator (checkmark) for networks with saved passwords
+      if (network.hasSavedPassword) {
+        renderer.drawText(UI_FONT_ID, pageWidth - 50, networkY, "+");
+      }
+
+      // Draw lock icon for encrypted networks
+      if (network.isEncrypted) {
+        renderer.drawText(UI_FONT_ID, pageWidth - 30, networkY, "*");
+      }
+    }
+
+    // Draw scroll indicators if needed
+    if (scrollOffset > 0) {
+      renderer.drawText(SMALL_FONT_ID, pageWidth - 15, startY - 10, "^");
+    }
+    if (scrollOffset + maxVisibleNetworks < static_cast<int>(networks.size())) {
+      renderer.drawText(SMALL_FONT_ID, pageWidth - 15, startY + maxVisibleNetworks * lineHeight, "v");
+    }
+
+    // Show network count
+    char countStr[32];
+    snprintf(countStr, sizeof(countStr), "%zu networks found", networks.size());
+    renderer.drawText(SMALL_FONT_ID, 20, pageHeight - 45, countStr);
+  }
+
+  // Draw help text
+  renderer.drawText(SMALL_FONT_ID, 20, pageHeight - 30, "OK: Connect | * = Encrypted | + = Saved");
+}
+
+void WifiSelectionActivity::renderPasswordEntry() const {
+  // Draw header
+  renderer.drawCenteredText(READER_FONT_ID, 5, "WiFi Password", true, BOLD);
+
+  // Draw network name with good spacing from header
+  std::string networkInfo = "Network: " + selectedSSID;
+  if (networkInfo.length() > 30) {
+    networkInfo.replace(27, networkInfo.length() - 27, "...");
+  }
+  renderer.drawCenteredText(UI_FONT_ID, 38, networkInfo.c_str(), true, REGULAR);
+
+  // Draw keyboard
+  if (keyboard) {
+    keyboard->render(58);
+  }
+}
+
+void WifiSelectionActivity::renderConnecting() const {
+  const auto pageHeight = renderer.getScreenHeight();
+  const auto height = renderer.getLineHeight(UI_FONT_ID);
+  const auto top = (pageHeight - height) / 2;
+
+  if (state == WifiSelectionState::SCANNING) {
+    renderer.drawCenteredText(UI_FONT_ID, top, "Scanning...", true, REGULAR);
+  } else {
+    renderer.drawCenteredText(READER_FONT_ID, top - 30, "Connecting...", true, BOLD);
+
+    std::string ssidInfo = "to " + selectedSSID;
+    if (ssidInfo.length() > 25) {
+      ssidInfo.replace(22, ssidInfo.length() - 22, "...");
+    }
+    renderer.drawCenteredText(UI_FONT_ID, top, ssidInfo.c_str(), true, REGULAR);
+  }
+}
+
+void WifiSelectionActivity::renderConnected() const {
+  const auto pageHeight = renderer.getScreenHeight();
+  const auto height = renderer.getLineHeight(UI_FONT_ID);
+  const auto top = (pageHeight - height * 4) / 2;
+
+  renderer.drawCenteredText(READER_FONT_ID, top - 30, "Connected!", true, BOLD);
+
+  std::string ssidInfo = "Network: " + selectedSSID;
+  if (ssidInfo.length() > 28) {
+    ssidInfo.replace(25, ssidInfo.length() - 25, "...");
+  }
+  renderer.drawCenteredText(UI_FONT_ID, top + 10, ssidInfo.c_str(), true, REGULAR);
+
+  std::string ipInfo = "IP Address: " + connectedIP;
+  renderer.drawCenteredText(UI_FONT_ID, top + 40, ipInfo.c_str(), true, REGULAR);
+
+  renderer.drawCenteredText(SMALL_FONT_ID, pageHeight - 30, "Press any button to continue", true, REGULAR);
+}
+
+void WifiSelectionActivity::renderSavePrompt() const {
+  const auto pageWidth = renderer.getScreenWidth();
+  const auto pageHeight = renderer.getScreenHeight();
+  const auto height = renderer.getLineHeight(UI_FONT_ID);
+  const auto top = (pageHeight - height * 3) / 2;
+
+  renderer.drawCenteredText(READER_FONT_ID, top - 40, "Connected!", true, BOLD);
+
+  std::string ssidInfo = "Network: " + selectedSSID;
+  if (ssidInfo.length() > 28) {
+    ssidInfo.replace(25, ssidInfo.length() - 25, "...");
+  }
+  renderer.drawCenteredText(UI_FONT_ID, top, ssidInfo.c_str(), true, REGULAR);
+
+  renderer.drawCenteredText(UI_FONT_ID, top + 40, "Save password for next time?", true, REGULAR);
+
+  // Draw Yes/No buttons
+  const int buttonY = top + 80;
+  const int buttonWidth = 60;
+  const int buttonSpacing = 30;
+  const int totalWidth = buttonWidth * 2 + buttonSpacing;
+  const int startX = (pageWidth - totalWidth) / 2;
+
+  // Draw "Yes" button
+  if (savePromptSelection == 0) {
+    renderer.drawText(UI_FONT_ID, startX, buttonY, "[Yes]");
+  } else {
+    renderer.drawText(UI_FONT_ID, startX + 4, buttonY, "Yes");
+  }
+
+  // Draw "No" button
+  if (savePromptSelection == 1) {
+    renderer.drawText(UI_FONT_ID, startX + buttonWidth + buttonSpacing, buttonY, "[No]");
+  } else {
+    renderer.drawText(UI_FONT_ID, startX + buttonWidth + buttonSpacing + 4, buttonY, "No");
+  }
+
+  renderer.drawCenteredText(SMALL_FONT_ID, pageHeight - 30, "LEFT/RIGHT: Select | OK: Confirm", true, REGULAR);
+}
+
+void WifiSelectionActivity::renderConnectionFailed() const {
+  const auto pageHeight = renderer.getScreenHeight();
+  const auto height = renderer.getLineHeight(UI_FONT_ID);
+  const auto top = (pageHeight - height * 2) / 2;
+
+  renderer.drawCenteredText(READER_FONT_ID, top - 20, "Connection Failed", true, BOLD);
+  renderer.drawCenteredText(UI_FONT_ID, top + 20, connectionError.c_str(), true, REGULAR);
+  renderer.drawCenteredText(SMALL_FONT_ID, pageHeight - 30, "Press any button to continue", true, REGULAR);
+}
+
+void WifiSelectionActivity::renderForgetPrompt() const {
+  const auto pageWidth = renderer.getScreenWidth();
+  const auto pageHeight = renderer.getScreenHeight();
+  const auto height = renderer.getLineHeight(UI_FONT_ID);
+  const auto top = (pageHeight - height * 3) / 2;
+
+  renderer.drawCenteredText(READER_FONT_ID, top - 40, "Forget Network?", true, BOLD);
+
+  std::string ssidInfo = "Network: " + selectedSSID;
+  if (ssidInfo.length() > 28) {
+    ssidInfo.replace(25, ssidInfo.length() - 25, "...");
+  }
+  renderer.drawCenteredText(UI_FONT_ID, top, ssidInfo.c_str(), true, REGULAR);
+
+  renderer.drawCenteredText(UI_FONT_ID, top + 40, "Remove saved password?", true, REGULAR);
+
+  // Draw Yes/No buttons
+  const int buttonY = top + 80;
+  const int buttonWidth = 60;
+  const int buttonSpacing = 30;
+  const int totalWidth = buttonWidth * 2 + buttonSpacing;
+  const int startX = (pageWidth - totalWidth) / 2;
+
+  // Draw "Yes" button
+  if (forgetPromptSelection == 0) {
+    renderer.drawText(UI_FONT_ID, startX, buttonY, "[Yes]");
+  } else {
+    renderer.drawText(UI_FONT_ID, startX + 4, buttonY, "Yes");
+  }
+
+  // Draw "No" button
+  if (forgetPromptSelection == 1) {
+    renderer.drawText(UI_FONT_ID, startX + buttonWidth + buttonSpacing, buttonY, "[No]");
+  } else {
+    renderer.drawText(UI_FONT_ID, startX + buttonWidth + buttonSpacing + 4, buttonY, "No");
+  }
+
+  renderer.drawCenteredText(SMALL_FONT_ID, pageHeight - 30, "LEFT/RIGHT: Select | OK: Confirm", true, REGULAR);
+}

src/activities/network/WifiSelectionActivity.h

@@ -0,0 +1,108 @@
+#pragma once
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "../Activity.h"
+#include "../util/KeyboardEntryActivity.h"
+
+// Structure to hold WiFi network information
+struct WifiNetworkInfo {
+  std::string ssid;
+  int32_t rssi;
+  bool isEncrypted;
+  bool hasSavedPassword;  // Whether we have saved credentials for this network
+};
+
+// WiFi selection states
+enum class WifiSelectionState {
+  SCANNING,           // Scanning for networks
+  NETWORK_LIST,       // Displaying available networks
+  PASSWORD_ENTRY,     // Entering password for selected network
+  CONNECTING,         // Attempting to connect
+  CONNECTED,          // Successfully connected
+  SAVE_PROMPT,        // Asking user if they want to save the password
+  CONNECTION_FAILED,  // Connection failed
+  FORGET_PROMPT       // Asking user if they want to forget the network
+};
+
+/**
+ * WifiSelectionActivity is responsible for scanning WiFi APs and connecting to them.
+ * It will:
+ * - Enter scanning mode on entry
+ * - List available WiFi networks
+ * - Allow selection and launch KeyboardEntryActivity for password if needed
+ * - Save the password if requested
+ * - Call onComplete callback when connected or cancelled
+ *
+ * The onComplete callback receives true if connected successfully, false if cancelled.
+ */
+class WifiSelectionActivity final : public Activity {
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  bool updateRequired = false;
+  WifiSelectionState state = WifiSelectionState::SCANNING;
+  int selectedNetworkIndex = 0;
+  std::vector<WifiNetworkInfo> networks;
+  const std::function<void(bool connected)> onComplete;
+
+  // Selected network for connection
+  std::string selectedSSID;
+  bool selectedRequiresPassword = false;
+
+  // On-screen keyboard for password entry
+  std::unique_ptr<KeyboardEntryActivity> keyboard;
+
+  // Connection result
+  std::string connectedIP;
+  std::string connectionError;
+
+  // Password to potentially save (from keyboard or saved credentials)
+  std::string enteredPassword;
+
+  // Whether network was connected using a saved password (skip save prompt)
+  bool usedSavedPassword = false;
+
+  // Save/forget prompt selection (0 = Yes, 1 = No)
+  int savePromptSelection = 0;
+  int forgetPromptSelection = 0;
+
+  // Connection timeout
+  static constexpr unsigned long CONNECTION_TIMEOUT_MS = 15000;
+  unsigned long connectionStartTime = 0;
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void render() const;
+  void renderNetworkList() const;
+  void renderPasswordEntry() const;
+  void renderConnecting() const;
+  void renderConnected() const;
+  void renderSavePrompt() const;
+  void renderConnectionFailed() const;
+  void renderForgetPrompt() const;
+
+  void startWifiScan();
+  void processWifiScanResults();
+  void selectNetwork(int index);
+  void attemptConnection();
+  void checkConnectionStatus();
+  std::string getSignalStrengthIndicator(int32_t rssi) const;
+
+ public:
+  explicit WifiSelectionActivity(GfxRenderer& renderer, InputManager& inputManager,
+                                 const std::function<void(bool connected)>& onComplete)
+      : Activity(renderer, inputManager), onComplete(onComplete) {}
+  void onEnter() override;
+  void onExit() override;
+  void loop() override;
+
+  // Get the IP address after successful connection
+  const std::string& getConnectedIP() const { return connectedIP; }
+};

src/activities/network/server/CrossPointWebServer.cpp

@@ -0,0 +1,726 @@
+#include "CrossPointWebServer.h"
+
+#include <SD.h>
+#include <WiFi.h>
+
+#include <algorithm>
+
+#include "config.h"
+#include "html/FilesPageFooterHtml.generated.h"
+#include "html/FilesPageHeaderHtml.generated.h"
+#include "html/HomePageHtml.generated.h"
+
+namespace {
+
+// Folders/files to hide from the web interface file browser
+// Note: Items starting with "." are automatically hidden
+const char* HIDDEN_ITEMS[] = {"System Volume Information", "XTCache"};
+const size_t HIDDEN_ITEMS_COUNT = sizeof(HIDDEN_ITEMS) / sizeof(HIDDEN_ITEMS[0]);
+
+// Helper function to escape HTML special characters to prevent XSS
+String escapeHtml(const String& input) {
+  String output;
+  output.reserve(input.length() * 1.1);  // Pre-allocate with some extra space
+
+  for (size_t i = 0; i < input.length(); i++) {
+    char c = input.charAt(i);
+    switch (c) {
+      case '&':
+        output += "&amp;";
+        break;
+      case '<':
+        output += "&lt;";
+        break;
+      case '>':
+        output += "&gt;";
+        break;
+      case '"':
+        output += "&quot;";
+        break;
+      case '\'':
+        output += "&#39;";
+        break;
+      default:
+        output += c;
+        break;
+    }
+  }
+  return output;
+}
+
+}  // namespace
+
+// File listing page template - now using generated headers:
+// - HomePageHtml (from html/HomePage.html)
+// - FilesPageHeaderHtml (from html/FilesPageHeader.html)
+// - FilesPageFooterHtml (from html/FilesPageFooter.html)
+CrossPointWebServer::CrossPointWebServer() {}
+
+CrossPointWebServer::~CrossPointWebServer() { stop(); }
+
+void CrossPointWebServer::begin() {
+  if (running) {
+    Serial.printf("[%lu] [WEB] Web server already running\n", millis());
+    return;
+  }
+
+  if (WiFi.status() != WL_CONNECTED) {
+    Serial.printf("[%lu] [WEB] Cannot start webserver - WiFi not connected\n", millis());
+    return;
+  }
+
+  Serial.printf("[%lu] [WEB] [MEM] Free heap before begin: %d bytes\n", millis(), ESP.getFreeHeap());
+
+  Serial.printf("[%lu] [WEB] Creating web server on port %d...\n", millis(), port);
+  server = new WebServer(port);
+  Serial.printf("[%lu] [WEB] [MEM] Free heap after WebServer allocation: %d bytes\n", millis(), ESP.getFreeHeap());
+
+  if (!server) {
+    Serial.printf("[%lu] [WEB] Failed to create WebServer!\n", millis());
+    return;
+  }
+
+  // Setup routes
+  Serial.printf("[%lu] [WEB] Setting up routes...\n", millis());
+  server->on("/", HTTP_GET, [this]() { handleRoot(); });
+  server->on("/status", HTTP_GET, [this]() { handleStatus(); });
+  server->on("/files", HTTP_GET, [this]() { handleFileList(); });
+
+  // Upload endpoint with special handling for multipart form data
+  server->on("/upload", HTTP_POST, [this]() { handleUploadPost(); }, [this]() { handleUpload(); });
+
+  // Create folder endpoint
+  server->on("/mkdir", HTTP_POST, [this]() { handleCreateFolder(); });
+
+  // Delete file/folder endpoint
+  server->on("/delete", HTTP_POST, [this]() { handleDelete(); });
+
+  server->onNotFound([this]() { handleNotFound(); });
+  Serial.printf("[%lu] [WEB] [MEM] Free heap after route setup: %d bytes\n", millis(), ESP.getFreeHeap());
+
+  server->begin();
+  running = true;
+
+  Serial.printf("[%lu] [WEB] Web server started on port %d\n", millis(), port);
+  Serial.printf("[%lu] [WEB] Access at http://%s/\n", millis(), WiFi.localIP().toString().c_str());
+  Serial.printf("[%lu] [WEB] [MEM] Free heap after server.begin(): %d bytes\n", millis(), ESP.getFreeHeap());
+}
+
+void CrossPointWebServer::stop() {
+  if (!running || !server) {
+    Serial.printf("[%lu] [WEB] stop() called but already stopped (running=%d, server=%p)\n", millis(), running, server);
+    return;
+  }
+
+  Serial.printf("[%lu] [WEB] STOP INITIATED - setting running=false first\n", millis());
+  running = false;  // Set this FIRST to prevent handleClient from using server
+
+  Serial.printf("[%lu] [WEB] [MEM] Free heap before stop: %d bytes\n", millis(), ESP.getFreeHeap());
+
+  // Add delay to allow any in-flight handleClient() calls to complete
+  delay(100);
+  Serial.printf("[%lu] [WEB] Waited 100ms for handleClient to finish\n", millis());
+
+  server->stop();
+  Serial.printf("[%lu] [WEB] [MEM] Free heap after server->stop(): %d bytes\n", millis(), ESP.getFreeHeap());
+
+  // Add another delay before deletion to ensure server->stop() completes
+  delay(50);
+  Serial.printf("[%lu] [WEB] Waited 50ms before deleting server\n", millis());
+
+  delete server;
+  server = nullptr;
+
+  Serial.printf("[%lu] [WEB] Web server stopped and deleted\n", millis());
+  Serial.printf("[%lu] [WEB] [MEM] Free heap after delete server: %d bytes\n", millis(), ESP.getFreeHeap());
+
+  // Note: Static upload variables (uploadFileName, uploadPath, uploadError) are declared
+  // later in the file and will be cleared when they go out of scope or on next upload
+  Serial.printf("[%lu] [WEB] [MEM] Free heap final: %d bytes\n", millis(), ESP.getFreeHeap());
+}
+
+void CrossPointWebServer::handleClient() {
+  static unsigned long lastDebugPrint = 0;
+
+  // Check running flag FIRST before accessing server
+  if (!running) {
+    return;
+  }
+
+  // Double-check server pointer is valid
+  if (!server) {
+    Serial.printf("[%lu] [WEB] WARNING: handleClient called with null server!\n", millis());
+    return;
+  }
+
+  // Print debug every 10 seconds to confirm handleClient is being called
+  if (millis() - lastDebugPrint > 10000) {
+    Serial.printf("[%lu] [WEB] handleClient active, server running on port %d\n", millis(), port);
+    lastDebugPrint = millis();
+  }
+
+  server->handleClient();
+}
+
+void CrossPointWebServer::handleRoot() {
+  String html = HomePageHtml;
+
+  // Replace placeholders with actual values
+  html.replace("%VERSION%", CROSSPOINT_VERSION);
+  html.replace("%IP_ADDRESS%", WiFi.localIP().toString());
+  html.replace("%FREE_HEAP%", String(ESP.getFreeHeap()));
+
+  server->send(200, "text/html", html);
+  Serial.printf("[%lu] [WEB] Served root page\n", millis());
+}
+
+void CrossPointWebServer::handleNotFound() {
+  String message = "404 Not Found\n\n";
+  message += "URI: " + server->uri() + "\n";
+  server->send(404, "text/plain", message);
+}
+
+void CrossPointWebServer::handleStatus() {
+  String json = "{";
+  json += "\"version\":\"" + String(CROSSPOINT_VERSION) + "\",";
+  json += "\"ip\":\"" + WiFi.localIP().toString() + "\",";
+  json += "\"rssi\":" + String(WiFi.RSSI()) + ",";
+  json += "\"freeHeap\":" + String(ESP.getFreeHeap()) + ",";
+  json += "\"uptime\":" + String(millis() / 1000);
+  json += "}";
+
+  server->send(200, "application/json", json);
+}
+
+std::vector<FileInfo> CrossPointWebServer::scanFiles(const char* path) {
+  std::vector<FileInfo> files;
+
+  File root = SD.open(path);
+  if (!root) {
+    Serial.printf("[%lu] [WEB] Failed to open directory: %s\n", millis(), path);
+    return files;
+  }
+
+  if (!root.isDirectory()) {
+    Serial.printf("[%lu] [WEB] Not a directory: %s\n", millis(), path);
+    root.close();
+    return files;
+  }
+
+  Serial.printf("[%lu] [WEB] Scanning files in: %s\n", millis(), path);
+
+  File file = root.openNextFile();
+  while (file) {
+    String fileName = String(file.name());
+
+    // Skip hidden items (starting with ".")
+    bool shouldHide = fileName.startsWith(".");
+
+    // Check against explicitly hidden items list
+    if (!shouldHide) {
+      for (size_t i = 0; i < HIDDEN_ITEMS_COUNT; i++) {
+        if (fileName.equals(HIDDEN_ITEMS[i])) {
+          shouldHide = true;
+          break;
+        }
+      }
+    }
+
+    if (!shouldHide) {
+      FileInfo info;
+      info.name = fileName;
+      info.isDirectory = file.isDirectory();
+
+      if (info.isDirectory) {
+        info.size = 0;
+        info.isEpub = false;
+      } else {
+        info.size = file.size();
+        info.isEpub = isEpubFile(info.name);
+      }
+
+      files.push_back(info);
+    }
+
+    file.close();
+    file = root.openNextFile();
+  }
+  root.close();
+
+  Serial.printf("[%lu] [WEB] Found %d items (files and folders)\n", millis(), files.size());
+  return files;
+}
+
+String CrossPointWebServer::formatFileSize(size_t bytes) {
+  if (bytes < 1024) {
+    return String(bytes) + " B";
+  } else if (bytes < 1024 * 1024) {
+    return String(bytes / 1024.0, 1) + " KB";
+  } else {
+    return String(bytes / (1024.0 * 1024.0), 1) + " MB";
+  }
+}
+
+bool CrossPointWebServer::isEpubFile(const String& filename) {
+  String lower = filename;
+  lower.toLowerCase();
+  return lower.endsWith(".epub");
+}
+
+void CrossPointWebServer::handleFileList() {
+  String html = FilesPageHeaderHtml;
+
+  // Get current path from query string (default to root)
+  String currentPath = "/";
+  if (server->hasArg("path")) {
+    currentPath = server->arg("path");
+    // Ensure path starts with /
+    if (!currentPath.startsWith("/")) {
+      currentPath = "/" + currentPath;
+    }
+    // Remove trailing slash unless it's root
+    if (currentPath.length() > 1 && currentPath.endsWith("/")) {
+      currentPath = currentPath.substring(0, currentPath.length() - 1);
+    }
+  }
+
+  // Get message from query string if present
+  if (server->hasArg("msg")) {
+    String msg = escapeHtml(server->arg("msg"));
+    String msgType = server->hasArg("type") ? escapeHtml(server->arg("type")) : "success";
+    html += "<div class=\"message " + msgType + "\">" + msg + "</div>";
+  }
+
+  // Hidden input to store current path for JavaScript
+  html += "<input type=\"hidden\" id=\"currentPath\" value=\"" + currentPath + "\">";
+
+  // Scan files in current path first (we need counts for the header)
+  std::vector<FileInfo> files = scanFiles(currentPath.c_str());
+
+  // Count items
+  int epubCount = 0;
+  int folderCount = 0;
+  size_t totalSize = 0;
+  for (const auto& file : files) {
+    if (file.isDirectory) {
+      folderCount++;
+    } else {
+      if (file.isEpub) epubCount++;
+      totalSize += file.size;
+    }
+  }
+
+  // Page header with inline breadcrumb and action buttons
+  html += "<div class=\"page-header\">";
+  html += "<div class=\"page-header-left\">";
+  html += "<h1>📁 File Manager</h1>";
+
+  // Inline breadcrumb
+  html += "<div class=\"breadcrumb-inline\">";
+  html += "<span class=\"sep\">/</span>";
+
+  if (currentPath == "/") {
+    html += "<span class=\"current\">🏠</span>";
+  } else {
+    html += "<a href=\"/files\">🏠</a>";
+    String pathParts = currentPath.substring(1);  // Remove leading /
+    String buildPath = "";
+    int start = 0;
+    int end = pathParts.indexOf('/');
+
+    while (start < (int)pathParts.length()) {
+      String part;
+      if (end == -1) {
+        part = pathParts.substring(start);
+        buildPath += "/" + part;
+        html += "<span class=\"sep\">/</span><span class=\"current\">" + escapeHtml(part) + "</span>";
+        break;
+      } else {
+        part = pathParts.substring(start, end);
+        buildPath += "/" + part;
+        html += "<span class=\"sep\">/</span><a href=\"/files?path=" + buildPath + "\">" + escapeHtml(part) + "</a>";
+        start = end + 1;
+        end = pathParts.indexOf('/', start);
+      }
+    }
+  }
+  html += "</div>";
+  html += "</div>";
+
+  // Action buttons
+  html += "<div class=\"action-buttons\">";
+  html += "<button class=\"action-btn upload-action-btn\" onclick=\"openUploadModal()\">";
+  html += "📤 Upload";
+  html += "</button>";
+  html += "<button class=\"action-btn folder-action-btn\" onclick=\"openFolderModal()\">";
+  html += "📁 New Folder";
+  html += "</button>";
+  html += "</div>";
+
+  html += "</div>";  // end page-header
+
+  // Contents card with inline summary
+  html += "<div class=\"card\">";
+
+  // Contents header with inline stats
+  html += "<div class=\"contents-header\">";
+  html += "<h2 class=\"contents-title\">Contents</h2>";
+  html += "<span class=\"summary-inline\">";
+  html += String(folderCount) + " folder" + (folderCount != 1 ? "s" : "") + ", ";
+  html += String(files.size() - folderCount) + " file" + ((files.size() - folderCount) != 1 ? "s" : "") + ", ";
+  html += formatFileSize(totalSize);
+  html += "</span>";
+  html += "</div>";
+
+  if (files.empty()) {
+    html += "<div class=\"no-files\">This folder is empty</div>";
+  } else {
+    html += "<table class=\"file-table\">";
+    html += "<tr><th>Name</th><th>Type</th><th>Size</th><th class=\"actions-col\">Actions</th></tr>";
+
+    // Sort files: folders first, then epub files, then other files, alphabetically within each group
+    std::sort(files.begin(), files.end(), [](const FileInfo& a, const FileInfo& b) {
+      // Folders come first
+      if (a.isDirectory != b.isDirectory) return a.isDirectory > b.isDirectory;
+      // Then sort by epub status (epubs first among files)
+      if (a.isEpub != b.isEpub) return a.isEpub > b.isEpub;
+      // Then alphabetically
+      return a.name < b.name;
+    });
+
+    for (const auto& file : files) {
+      String rowClass;
+      String icon;
+      String badge;
+      String typeStr;
+      String sizeStr;
+
+      if (file.isDirectory) {
+        rowClass = "folder-row";
+        icon = "📁";
+        badge = "<span class=\"folder-badge\">FOLDER</span>";
+        typeStr = "Folder";
+        sizeStr = "-";
+
+        // Build the path to this folder
+        String folderPath = currentPath;
+        if (!folderPath.endsWith("/")) folderPath += "/";
+        folderPath += file.name;
+
+        html += "<tr class=\"" + rowClass + "\">";
+        html += "<td><span class=\"file-icon\">" + icon + "</span>";
+        html += "<a href=\"/files?path=" + folderPath + "\" class=\"folder-link\">" + escapeHtml(file.name) + "</a>" +
+                badge + "</td>";
+        html += "<td>" + typeStr + "</td>";
+        html += "<td>" + sizeStr + "</td>";
+        // Escape quotes for JavaScript string
+        String escapedName = file.name;
+        escapedName.replace("'", "\\'");
+        String escapedPath = folderPath;
+        escapedPath.replace("'", "\\'");
+        html += "<td class=\"actions-col\"><button class=\"delete-btn\" onclick=\"openDeleteModal('" + escapedName +
+                "', '" + escapedPath + "', true)\" title=\"Delete folder\">🗑️</button></td>";
+        html += "</tr>";
+      } else {
+        rowClass = file.isEpub ? "epub-file" : "";
+        icon = file.isEpub ? "📗" : "📄";
+        badge = file.isEpub ? "<span class=\"epub-badge\">EPUB</span>" : "";
+        String ext = file.name.substring(file.name.lastIndexOf('.') + 1);
+        ext.toUpperCase();
+        typeStr = ext;
+        sizeStr = formatFileSize(file.size);
+
+        // Build file path for delete
+        String filePath = currentPath;
+        if (!filePath.endsWith("/")) filePath += "/";
+        filePath += file.name;
+
+        html += "<tr class=\"" + rowClass + "\">";
+        html += "<td><span class=\"file-icon\">" + icon + "</span>" + escapeHtml(file.name) + badge + "</td>";
+        html += "<td>" + typeStr + "</td>";
+        html += "<td>" + sizeStr + "</td>";
+        // Escape quotes for JavaScript string
+        String escapedName = file.name;
+        escapedName.replace("'", "\\'");
+        String escapedPath = filePath;
+        escapedPath.replace("'", "\\'");
+        html += "<td class=\"actions-col\"><button class=\"delete-btn\" onclick=\"openDeleteModal('" + escapedName +
+                "', '" + escapedPath + "', false)\" title=\"Delete file\">🗑️</button></td>";
+        html += "</tr>";
+      }
+    }
+
+    html += "</table>";
+  }
+
+  html += "</div>";
+
+  html += FilesPageFooterHtml;
+
+  server->send(200, "text/html", html);
+  Serial.printf("[%lu] [WEB] Served file listing page for path: %s\n", millis(), currentPath.c_str());
+}
+
+// Static variables for upload handling
+static File uploadFile;
+static String uploadFileName;
+static String uploadPath = "/";
+static size_t uploadSize = 0;
+static bool uploadSuccess = false;
+static String uploadError = "";
+
+void CrossPointWebServer::handleUpload() {
+  static unsigned long lastWriteTime = 0;
+  static unsigned long uploadStartTime = 0;
+  static size_t lastLoggedSize = 0;
+
+  // Safety check: ensure server is still valid
+  if (!running || !server) {
+    Serial.printf("[%lu] [WEB] [UPLOAD] ERROR: handleUpload called but server not running!\n", millis());
+    return;
+  }
+
+  HTTPUpload& upload = server->upload();
+
+  if (upload.status == UPLOAD_FILE_START) {
+    uploadFileName = upload.filename;
+    uploadSize = 0;
+    uploadSuccess = false;
+    uploadError = "";
+    uploadStartTime = millis();
+    lastWriteTime = millis();
+    lastLoggedSize = 0;
+
+    // Get upload path from query parameter (defaults to root if not specified)
+    // Note: We use query parameter instead of form data because multipart form
+    // fields aren't available until after file upload completes
+    if (server->hasArg("path")) {
+      uploadPath = server->arg("path");
+      // Ensure path starts with /
+      if (!uploadPath.startsWith("/")) {
+        uploadPath = "/" + uploadPath;
+      }
+      // Remove trailing slash unless it's root
+      if (uploadPath.length() > 1 && uploadPath.endsWith("/")) {
+        uploadPath = uploadPath.substring(0, uploadPath.length() - 1);
+      }
+    } else {
+      uploadPath = "/";
+    }
+
+    Serial.printf("[%lu] [WEB] [UPLOAD] START: %s to path: %s\n", millis(), uploadFileName.c_str(), uploadPath.c_str());
+    Serial.printf("[%lu] [WEB] [UPLOAD] Free heap: %d bytes\n", millis(), ESP.getFreeHeap());
+
+    // Create file path
+    String filePath = uploadPath;
+    if (!filePath.endsWith("/")) filePath += "/";
+    filePath += uploadFileName;
+
+    // Check if file already exists
+    if (SD.exists(filePath.c_str())) {
+      Serial.printf("[%lu] [WEB] [UPLOAD] Overwriting existing file: %s\n", millis(), filePath.c_str());
+      SD.remove(filePath.c_str());
+    }
+
+    // Open file for writing
+    uploadFile = SD.open(filePath.c_str(), FILE_WRITE);
+    if (!uploadFile) {
+      uploadError = "Failed to create file on SD card";
+      Serial.printf("[%lu] [WEB] [UPLOAD] FAILED to create file: %s\n", millis(), filePath.c_str());
+      return;
+    }
+
+    Serial.printf("[%lu] [WEB] [UPLOAD] File created successfully: %s\n", millis(), filePath.c_str());
+  } else if (upload.status == UPLOAD_FILE_WRITE) {
+    if (uploadFile && uploadError.isEmpty()) {
+      unsigned long writeStartTime = millis();
+      size_t written = uploadFile.write(upload.buf, upload.currentSize);
+      unsigned long writeEndTime = millis();
+      unsigned long writeDuration = writeEndTime - writeStartTime;
+
+      if (written != upload.currentSize) {
+        uploadError = "Failed to write to SD card - disk may be full";
+        uploadFile.close();
+        Serial.printf("[%lu] [WEB] [UPLOAD] WRITE ERROR - expected %d, wrote %d\n", millis(), upload.currentSize,
+                      written);
+      } else {
+        uploadSize += written;
+
+        // Log progress every 50KB or if write took >100ms
+        if (uploadSize - lastLoggedSize >= 51200 || writeDuration > 100) {
+          unsigned long timeSinceStart = millis() - uploadStartTime;
+          unsigned long timeSinceLastWrite = millis() - lastWriteTime;
+          float kbps = (uploadSize / 1024.0) / (timeSinceStart / 1000.0);
+
+          Serial.printf(
+              "[%lu] [WEB] [UPLOAD] Progress: %d bytes (%.1f KB), %.1f KB/s, write took %lu ms, gap since last: %lu "
+              "ms\n",
+              millis(), uploadSize, uploadSize / 1024.0, kbps, writeDuration, timeSinceLastWrite);
+          lastLoggedSize = uploadSize;
+        }
+        lastWriteTime = millis();
+      }
+    }
+  } else if (upload.status == UPLOAD_FILE_END) {
+    if (uploadFile) {
+      uploadFile.close();
+
+      if (uploadError.isEmpty()) {
+        uploadSuccess = true;
+        Serial.printf("[%lu] [WEB] Upload complete: %s (%d bytes)\n", millis(), uploadFileName.c_str(), uploadSize);
+      }
+    }
+  } else if (upload.status == UPLOAD_FILE_ABORTED) {
+    if (uploadFile) {
+      uploadFile.close();
+      // Try to delete the incomplete file
+      String filePath = uploadPath;
+      if (!filePath.endsWith("/")) filePath += "/";
+      filePath += uploadFileName;
+      SD.remove(filePath.c_str());
+    }
+    uploadError = "Upload aborted";
+    Serial.printf("[%lu] [WEB] Upload aborted\n", millis());
+  }
+}
+
+void CrossPointWebServer::handleUploadPost() {
+  if (uploadSuccess) {
+    server->send(200, "text/plain", "File uploaded successfully: " + uploadFileName);
+  } else {
+    String error = uploadError.isEmpty() ? "Unknown error during upload" : uploadError;
+    server->send(400, "text/plain", error);
+  }
+}
+
+void CrossPointWebServer::handleCreateFolder() {
+  // Get folder name from form data
+  if (!server->hasArg("name")) {
+    server->send(400, "text/plain", "Missing folder name");
+    return;
+  }
+
+  String folderName = server->arg("name");
+
+  // Validate folder name
+  if (folderName.isEmpty()) {
+    server->send(400, "text/plain", "Folder name cannot be empty");
+    return;
+  }
+
+  // Get parent path
+  String parentPath = "/";
+  if (server->hasArg("path")) {
+    parentPath = server->arg("path");
+    if (!parentPath.startsWith("/")) {
+      parentPath = "/" + parentPath;
+    }
+    if (parentPath.length() > 1 && parentPath.endsWith("/")) {
+      parentPath = parentPath.substring(0, parentPath.length() - 1);
+    }
+  }
+
+  // Build full folder path
+  String folderPath = parentPath;
+  if (!folderPath.endsWith("/")) folderPath += "/";
+  folderPath += folderName;
+
+  Serial.printf("[%lu] [WEB] Creating folder: %s\n", millis(), folderPath.c_str());
+
+  // Check if already exists
+  if (SD.exists(folderPath.c_str())) {
+    server->send(400, "text/plain", "Folder already exists");
+    return;
+  }
+
+  // Create the folder
+  if (SD.mkdir(folderPath.c_str())) {
+    Serial.printf("[%lu] [WEB] Folder created successfully: %s\n", millis(), folderPath.c_str());
+    server->send(200, "text/plain", "Folder created: " + folderName);
+  } else {
+    Serial.printf("[%lu] [WEB] Failed to create folder: %s\n", millis(), folderPath.c_str());
+    server->send(500, "text/plain", "Failed to create folder");
+  }
+}
+
+void CrossPointWebServer::handleDelete() {
+  // Get path from form data
+  if (!server->hasArg("path")) {
+    server->send(400, "text/plain", "Missing path");
+    return;
+  }
+
+  String itemPath = server->arg("path");
+  String itemType = server->hasArg("type") ? server->arg("type") : "file";
+
+  // Validate path
+  if (itemPath.isEmpty() || itemPath == "/") {
+    server->send(400, "text/plain", "Cannot delete root directory");
+    return;
+  }
+
+  // Ensure path starts with /
+  if (!itemPath.startsWith("/")) {
+    itemPath = "/" + itemPath;
+  }
+
+  // Security check: prevent deletion of protected items
+  String itemName = itemPath.substring(itemPath.lastIndexOf('/') + 1);
+
+  // Check if item starts with a dot (hidden/system file)
+  if (itemName.startsWith(".")) {
+    Serial.printf("[%lu] [WEB] Delete rejected - hidden/system item: %s\n", millis(), itemPath.c_str());
+    server->send(403, "text/plain", "Cannot delete system files");
+    return;
+  }
+
+  // Check against explicitly protected items
+  for (size_t i = 0; i < HIDDEN_ITEMS_COUNT; i++) {
+    if (itemName.equals(HIDDEN_ITEMS[i])) {
+      Serial.printf("[%lu] [WEB] Delete rejected - protected item: %s\n", millis(), itemPath.c_str());
+      server->send(403, "text/plain", "Cannot delete protected items");
+      return;
+    }
+  }
+
+  // Check if item exists
+  if (!SD.exists(itemPath.c_str())) {
+    Serial.printf("[%lu] [WEB] Delete failed - item not found: %s\n", millis(), itemPath.c_str());
+    server->send(404, "text/plain", "Item not found");
+    return;
+  }
+
+  Serial.printf("[%lu] [WEB] Attempting to delete %s: %s\n", millis(), itemType.c_str(), itemPath.c_str());
+
+  bool success = false;
+
+  if (itemType == "folder") {
+    // For folders, try to remove (will fail if not empty)
+    File dir = SD.open(itemPath.c_str());
+    if (dir && dir.isDirectory()) {
+      // Check if folder is empty
+      File entry = dir.openNextFile();
+      if (entry) {
+        // Folder is not empty
+        entry.close();
+        dir.close();
+        Serial.printf("[%lu] [WEB] Delete failed - folder not empty: %s\n", millis(), itemPath.c_str());
+        server->send(400, "text/plain", "Folder is not empty. Delete contents first.");
+        return;
+      }
+      dir.close();
+    }
+    success = SD.rmdir(itemPath.c_str());
+  } else {
+    // For files, use remove
+    success = SD.remove(itemPath.c_str());
+  }
+
+  if (success) {
+    Serial.printf("[%lu] [WEB] Successfully deleted: %s\n", millis(), itemPath.c_str());
+    server->send(200, "text/plain", "Deleted successfully");
+  } else {
+    Serial.printf("[%lu] [WEB] Failed to delete: %s\n", millis(), itemPath.c_str());
+    server->send(500, "text/plain", "Failed to delete item");
+  }
+}

src/activities/network/server/CrossPointWebServer.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <WebServer.h>
+
+#include <functional>
+#include <string>
+#include <vector>
+
+// Structure to hold file information
+struct FileInfo {
+  String name;
+  size_t size;
+  bool isEpub;
+  bool isDirectory;
+};
+
+class CrossPointWebServer {
+ public:
+  CrossPointWebServer();
+  ~CrossPointWebServer();
+
+  // Start the web server (call after WiFi is connected)
+  void begin();
+
+  // Stop the web server
+  void stop();
+
+  // Call this periodically to handle client requests
+  void handleClient();
+
+  // Check if server is running
+  bool isRunning() const { return running; }
+
+  // Get the port number
+  uint16_t getPort() const { return port; }
+
+ private:
+  WebServer* server = nullptr;
+  bool running = false;
+  uint16_t port = 80;
+
+  // File scanning
+  std::vector<FileInfo> scanFiles(const char* path = "/");
+  String formatFileSize(size_t bytes);
+  bool isEpubFile(const String& filename);
+
+  // Request handlers
+  void handleRoot();
+  void handleNotFound();
+  void handleStatus();
+  void handleFileList();
+  void handleUpload();
+  void handleUploadPost();
+  void handleCreateFolder();
+  void handleDelete();
+};

src/activities/reader/EpubReaderActivity.cpp

@@ -0,0 +1,397 @@
+#include "EpubReaderActivity.h"
+
+#include <Epub/Page.h>
+#include <GfxRenderer.h>
+#include <SD.h>
+
+#include "Battery.h"
+#include "CrossPointSettings.h"
+#include "CrossPointState.h"
+#include "EpubReaderChapterSelectionActivity.h"
+#include "config.h"
+
+namespace {
+constexpr int pagesPerRefresh = 15;
+constexpr unsigned long skipChapterMs = 700;
+constexpr float lineCompression = 0.95f;
+constexpr int marginTop = 8;
+constexpr int marginRight = 10;
+constexpr int marginBottom = 22;
+constexpr int marginLeft = 10;
+}  // namespace
+
+void EpubReaderActivity::taskTrampoline(void* param) {
+  auto* self = static_cast<EpubReaderActivity*>(param);
+  self->displayTaskLoop();
+}
+
+void EpubReaderActivity::onEnter() {
+  if (!epub) {
+    return;
+  }
+
+  renderingMutex = xSemaphoreCreateMutex();
+
+  epub->setupCacheDir();
+
+  File f = SD.open((epub->getCachePath() + "/progress.bin").c_str());
+  if (f) {
+    uint8_t data[4];
+    if (f.read(data, 4) == 4) {
+      currentSpineIndex = data[0] + (data[1] << 8);
+      nextPageNumber = data[2] + (data[3] << 8);
+      Serial.printf("[%lu] [ERS] Loaded cache: %d, %d\n", millis(), currentSpineIndex, nextPageNumber);
+    }
+    f.close();
+  }
+
+  // Save current epub as last opened epub
+  APP_STATE.openEpubPath = epub->getPath();
+  APP_STATE.saveToFile();
+
+  // Trigger first update
+  updateRequired = true;
+
+  xTaskCreate(&EpubReaderActivity::taskTrampoline, "EpubReaderActivityTask",
+              8192,               // Stack size
+              this,               // Parameters
+              1,                  // Priority
+              &displayTaskHandle  // Task handle
+  );
+}
+
+void EpubReaderActivity::onExit() {
+  // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+  }
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+  section.reset();
+  epub.reset();
+}
+
+void EpubReaderActivity::loop() {
+  // Pass input responsibility to sub activity if exists
+  if (subAcitivity) {
+    subAcitivity->loop();
+    return;
+  }
+
+  // Enter chapter selection activity
+  if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
+    // Don't start activity transition while rendering
+    xSemaphoreTake(renderingMutex, portMAX_DELAY);
+    subAcitivity.reset(new EpubReaderChapterSelectionActivity(
+        this->renderer, this->inputManager, epub, currentSpineIndex,
+        [this] {
+          subAcitivity->onExit();
+          subAcitivity.reset();
+          updateRequired = true;
+        },
+        [this](const int newSpineIndex) {
+          if (currentSpineIndex != newSpineIndex) {
+            currentSpineIndex = newSpineIndex;
+            nextPageNumber = 0;
+            section.reset();
+          }
+          subAcitivity->onExit();
+          subAcitivity.reset();
+          updateRequired = true;
+        }));
+    subAcitivity->onEnter();
+    xSemaphoreGive(renderingMutex);
+  }
+
+  if (inputManager.wasPressed(InputManager::BTN_BACK)) {
+    onGoBack();
+    return;
+  }
+
+  const bool prevReleased =
+      inputManager.wasReleased(InputManager::BTN_UP) || inputManager.wasReleased(InputManager::BTN_LEFT);
+  const bool nextReleased =
+      inputManager.wasReleased(InputManager::BTN_DOWN) || inputManager.wasReleased(InputManager::BTN_RIGHT);
+
+  if (!prevReleased && !nextReleased) {
+    return;
+  }
+
+  // any botton press when at end of the book goes back to the last page
+  if (currentSpineIndex > 0 && currentSpineIndex >= epub->getSpineItemsCount()) {
+    currentSpineIndex = epub->getSpineItemsCount() - 1;
+    nextPageNumber = UINT16_MAX;
+    updateRequired = true;
+    return;
+  }
+
+  const bool skipChapter = inputManager.getHeldTime() > skipChapterMs;
+
+  if (skipChapter) {
+    // We don't want to delete the section mid-render, so grab the semaphore
+    xSemaphoreTake(renderingMutex, portMAX_DELAY);
+    nextPageNumber = 0;
+    currentSpineIndex = nextReleased ? currentSpineIndex + 1 : currentSpineIndex - 1;
+    section.reset();
+    xSemaphoreGive(renderingMutex);
+    updateRequired = true;
+    return;
+  }
+
+  // No current section, attempt to rerender the book
+  if (!section) {
+    updateRequired = true;
+    return;
+  }
+
+  if (prevReleased) {
+    if (section->currentPage > 0) {
+      section->currentPage--;
+    } else {
+      // We don't want to delete the section mid-render, so grab the semaphore
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      nextPageNumber = UINT16_MAX;
+      currentSpineIndex--;
+      section.reset();
+      xSemaphoreGive(renderingMutex);
+    }
+    updateRequired = true;
+  } else {
+    if (section->currentPage < section->pageCount - 1) {
+      section->currentPage++;
+    } else {
+      // We don't want to delete the section mid-render, so grab the semaphore
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      nextPageNumber = 0;
+      currentSpineIndex++;
+      section.reset();
+      xSemaphoreGive(renderingMutex);
+    }
+    updateRequired = true;
+  }
+}
+
+void EpubReaderActivity::displayTaskLoop() {
+  while (true) {
+    if (updateRequired) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      renderScreen();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+// TODO: Failure handling
+void EpubReaderActivity::renderScreen() {
+  if (!epub) {
+    return;
+  }
+
+  // edge case handling for sub-zero spine index
+  if (currentSpineIndex < 0) {
+    currentSpineIndex = 0;
+  }
+  // based bounds of book, show end of book screen
+  if (currentSpineIndex > epub->getSpineItemsCount()) {
+    currentSpineIndex = epub->getSpineItemsCount();
+  }
+
+  // Show end of book screen
+  if (currentSpineIndex == epub->getSpineItemsCount()) {
+    renderer.clearScreen();
+    renderer.drawCenteredText(READER_FONT_ID, 300, "End of book", true, BOLD);
+    renderer.displayBuffer();
+    return;
+  }
+
+  if (!section) {
+    const auto filepath = epub->getSpineItem(currentSpineIndex);
+    Serial.printf("[%lu] [ERS] Loading file: %s, index: %d\n", millis(), filepath.c_str(), currentSpineIndex);
+    section = std::unique_ptr<Section>(new Section(epub, currentSpineIndex, renderer));
+    if (!section->loadCacheMetadata(READER_FONT_ID, lineCompression, marginTop, marginRight, marginBottom, marginLeft,
+                                    SETTINGS.extraParagraphSpacing)) {
+      Serial.printf("[%lu] [ERS] Cache not found, building...\n", millis());
+
+      {
+        const int textWidth = renderer.getTextWidth(READER_FONT_ID, "Indexing...");
+        constexpr int margin = 20;
+        const int x = (GfxRenderer::getScreenWidth() - textWidth - margin * 2) / 2;
+        constexpr int y = 50;
+        const int w = textWidth + margin * 2;
+        const int h = renderer.getLineHeight(READER_FONT_ID) + margin * 2;
+        renderer.fillRect(x, y, w, h, false);
+        renderer.drawText(READER_FONT_ID, x + margin, y + margin, "Indexing...");
+        renderer.drawRect(x + 5, y + 5, w - 10, h - 10);
+        renderer.displayBuffer();
+        pagesUntilFullRefresh = 0;
+      }
+
+      section->setupCacheDir();
+      if (!section->persistPageDataToSD(READER_FONT_ID, lineCompression, marginTop, marginRight, marginBottom,
+                                        marginLeft, SETTINGS.extraParagraphSpacing)) {
+        Serial.printf("[%lu] [ERS] Failed to persist page data to SD\n", millis());
+        section.reset();
+        return;
+      }
+    } else {
+      Serial.printf("[%lu] [ERS] Cache found, skipping build...\n", millis());
+    }
+
+    if (nextPageNumber == UINT16_MAX) {
+      section->currentPage = section->pageCount - 1;
+    } else {
+      section->currentPage = nextPageNumber;
+    }
+  }
+
+  renderer.clearScreen();
+
+  if (section->pageCount == 0) {
+    Serial.printf("[%lu] [ERS] No pages to render\n", millis());
+    renderer.drawCenteredText(READER_FONT_ID, 300, "Empty chapter", true, BOLD);
+    renderStatusBar();
+    renderer.displayBuffer();
+    return;
+  }
+
+  if (section->currentPage < 0 || section->currentPage >= section->pageCount) {
+    Serial.printf("[%lu] [ERS] Page out of bounds: %d (max %d)\n", millis(), section->currentPage, section->pageCount);
+    renderer.drawCenteredText(READER_FONT_ID, 300, "Out of bounds", true, BOLD);
+    renderStatusBar();
+    renderer.displayBuffer();
+    return;
+  }
+
+  {
+    auto p = section->loadPageFromSD();
+    if (!p) {
+      Serial.printf("[%lu] [ERS] Failed to load page from SD - clearing section cache\n", millis());
+      section->clearCache();
+      section.reset();
+      return renderScreen();
+    }
+    const auto start = millis();
+    renderContents(std::move(p));
+    Serial.printf("[%lu] [ERS] Rendered page in %dms\n", millis(), millis() - start);
+  }
+
+  File f = SD.open((epub->getCachePath() + "/progress.bin").c_str(), FILE_WRITE);
+  uint8_t data[4];
+  data[0] = currentSpineIndex & 0xFF;
+  data[1] = (currentSpineIndex >> 8) & 0xFF;
+  data[2] = section->currentPage & 0xFF;
+  data[3] = (section->currentPage >> 8) & 0xFF;
+  f.write(data, 4);
+  f.close();
+}
+
+void EpubReaderActivity::renderContents(std::unique_ptr<Page> page) {
+  page->render(renderer, READER_FONT_ID);
+  renderStatusBar();
+  if (pagesUntilFullRefresh <= 1) {
+    renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
+    pagesUntilFullRefresh = pagesPerRefresh;
+  } else {
+    renderer.displayBuffer();
+    pagesUntilFullRefresh--;
+  }
+
+  // Save bw buffer to reset buffer state after grayscale data sync
+  renderer.storeBwBuffer();
+
+  // grayscale rendering
+  // TODO: Only do this if font supports it
+  {
+    renderer.clearScreen(0x00);
+    renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB);
+    page->render(renderer, READER_FONT_ID);
+    renderer.copyGrayscaleLsbBuffers();
+
+    // Render and copy to MSB buffer
+    renderer.clearScreen(0x00);
+    renderer.setRenderMode(GfxRenderer::GRAYSCALE_MSB);
+    page->render(renderer, READER_FONT_ID);
+    renderer.copyGrayscaleMsbBuffers();
+
+    // display grayscale part
+    renderer.displayGrayBuffer();
+    renderer.setRenderMode(GfxRenderer::BW);
+  }
+
+  // restore the bw data
+  renderer.restoreBwBuffer();
+}
+
+void EpubReaderActivity::renderStatusBar() const {
+  constexpr auto textY = 776;
+
+  // Calculate progress in book
+  float sectionChapterProg = static_cast<float>(section->currentPage) / section->pageCount;
+  uint8_t bookProgress = epub->calculateProgress(currentSpineIndex, sectionChapterProg);
+
+  // Right aligned text for progress counter
+  const std::string progress = std::to_string(section->currentPage + 1) + "/" + std::to_string(section->pageCount) +
+                               "  " + std::to_string(bookProgress) + "%";
+  const auto progressTextWidth = renderer.getTextWidth(SMALL_FONT_ID, progress.c_str());
+  renderer.drawText(SMALL_FONT_ID, GfxRenderer::getScreenWidth() - marginRight - progressTextWidth, textY,
+                    progress.c_str());
+
+  // Left aligned battery icon and percentage
+  const uint16_t percentage = battery.readPercentage();
+  const auto percentageText = std::to_string(percentage) + "%";
+  const auto percentageTextWidth = renderer.getTextWidth(SMALL_FONT_ID, percentageText.c_str());
+  renderer.drawText(SMALL_FONT_ID, 20 + marginLeft, textY, percentageText.c_str());
+
+  // 1 column on left, 2 columns on right, 5 columns of battery body
+  constexpr int batteryWidth = 15;
+  constexpr int batteryHeight = 10;
+  constexpr int x = marginLeft;
+  constexpr int y = 783;
+
+  // Top line
+  renderer.drawLine(x, y, x + batteryWidth - 4, y);
+  // Bottom line
+  renderer.drawLine(x, y + batteryHeight - 1, x + batteryWidth - 4, y + batteryHeight - 1);
+  // Left line
+  renderer.drawLine(x, y, x, y + batteryHeight - 1);
+  // Battery end
+  renderer.drawLine(x + batteryWidth - 4, y, x + batteryWidth - 4, y + batteryHeight - 1);
+  renderer.drawLine(x + batteryWidth - 3, y + 2, x + batteryWidth - 1, y + 2);
+  renderer.drawLine(x + batteryWidth - 3, y + batteryHeight - 3, x + batteryWidth - 1, y + batteryHeight - 3);
+  renderer.drawLine(x + batteryWidth - 1, y + 2, x + batteryWidth - 1, y + batteryHeight - 3);
+
+  // The +1 is to round up, so that we always fill at least one pixel
+  int filledWidth = percentage * (batteryWidth - 5) / 100 + 1;
+  if (filledWidth > batteryWidth - 5) {
+    filledWidth = batteryWidth - 5;  // Ensure we don't overflow
+  }
+  renderer.fillRect(x + 1, y + 1, filledWidth, batteryHeight - 2);
+
+  // Centered chatper title text
+  // Page width minus existing content with 30px padding on each side
+  const int titleMarginLeft = 20 + percentageTextWidth + 30 + marginLeft;
+  const int titleMarginRight = progressTextWidth + 30 + marginRight;
+  const int availableTextWidth = GfxRenderer::getScreenWidth() - titleMarginLeft - titleMarginRight;
+  const int tocIndex = epub->getTocIndexForSpineIndex(currentSpineIndex);
+
+  std::string title;
+  int titleWidth;
+  if (tocIndex == -1) {
+    title = "Unnamed";
+    titleWidth = renderer.getTextWidth(SMALL_FONT_ID, "Unnamed");
+  } else {
+    const auto tocItem = epub->getTocItem(tocIndex);
+    title = tocItem.title;
+    titleWidth = renderer.getTextWidth(SMALL_FONT_ID, title.c_str());
+    while (titleWidth > availableTextWidth && title.length() > 11) {
+      title.replace(title.length() - 8, 8, "...");
+      titleWidth = renderer.getTextWidth(SMALL_FONT_ID, title.c_str());
+    }
+  }
+
+  renderer.drawText(SMALL_FONT_ID, titleMarginLeft + (availableTextWidth - titleWidth) / 2, textY, title.c_str());
+}

src/activities/reader/EpubReaderActivity.h

@@ -0,0 +1,35 @@
+#pragma once
+#include <Epub.h>
+#include <Epub/Section.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include "../Activity.h"
+
+class EpubReaderActivity final : public Activity {
+  std::shared_ptr<Epub> epub;
+  std::unique_ptr<Section> section = nullptr;
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  std::unique_ptr<Activity> subAcitivity = nullptr;
+  int currentSpineIndex = 0;
+  int nextPageNumber = 0;
+  int pagesUntilFullRefresh = 0;
+  bool updateRequired = false;
+  const std::function<void()> onGoBack;
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void renderScreen();
+  void renderContents(std::unique_ptr<Page> p);
+  void renderStatusBar() const;
+
+ public:
+  explicit EpubReaderActivity(GfxRenderer& renderer, InputManager& inputManager, std::unique_ptr<Epub> epub,
+                              const std::function<void()>& onGoBack)
+      : Activity(renderer, inputManager), epub(std::move(epub)), onGoBack(onGoBack) {}
+  void onEnter() override;
+  void onExit() override;
+  void loop() override;
+};