chore(release): bump version to 0.3.3

Behebt Datenverlust nach Neustart auf einer späteren Seite (v0.2.3 – v0.3.2); Seitenauswahl mit Vorschaubildern. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
feat(ui): Vorschaubilder in der Seitenauswahl
2026-10-07 07:32:58 +02:00 · 2026-10-07 07:03:08 +02:00 · 2026-10-07 07:03:08 +02:00 · 2026-10-07 06:40:44 +02:00 · 2026-10-06 23:51:48 +02:00 · 2026-10-06 23:16:54 +02:00
18 changed files with 2880 additions and 1383 deletions
@@ -44,18 +44,28 @@ jobs:
        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
        with:
          toolchain: stable
+          # Die Action installiert mit --profile minimal; ohne diese Komponenten
+          # schlagen cargo fmt und cargo clippy in den Quality Gates sofort fehl
+          components: rustfmt, clippy
          cache: true

+      - name: Install rsign2 (Release-Signatur)
+        # RUSTFLAGS leeren: die Toolchain-Action setzt -D warnings, das soll nicht für rsign2 gelten
+        run: RUSTFLAGS="" cargo install rsign2 --locked --version 0.6.7
+
      - name: Code Quality & Testing (Quality Gates)
        run: |
          cargo fmt --check
          cargo clippy --all-targets -- -D warnings
          cargo test

-      - name: Build Release Artifacts (.deb, .AppImage, SHA256SUMS.txt)
+      - name: Build Release Artifacts (.deb, .AppImage, SHA256SUMS.txt + .minisig)
        run: |
          chmod +x scripts/*.sh
          ./scripts/build-release.sh
+        env:
+          MINISIGN_SECRET_KEY: ${{ secrets.MINISIGN_SECRET_KEY }}
+          INK_NOTES_REQUIRE_SIGNATURE: "1"

      - name: Publish Release to Gitea
        run: |
@@ -1048,7 +1048,7 @@ dependencies = [

 [[package]]
 name = "ink-notes"
-version = "0.1.1"
+version = "0.3.3"
 dependencies = [
 "bytemuck",
 "egui",
@@ -1056,6 +1056,7 @@ dependencies = [
 "egui-winit",
 "fs2",
 "glam",
+ "minisign-verify",
 "octotablet",
 "pollster",
 "printpdf",
@@ -1304,6 +1305,12 @@ dependencies = [
 "paste",
 ]

+[[package]]
+name = "minisign-verify"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "871285dc19d8d0ebe0eef3d0e99a205f2a71363b122632cbbfa4a6c370a960ce"
+
 [[package]]
 name = "miniz_oxide"
 version = "0.9.1"
@@ -1,6 +1,6 @@
 [package]
 name = "ink-notes"
-version = "0.1.1"
+version = "0.3.3"
 edition = "2021"
 description = "Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux"
 repository = "https://gitea.pansi.eu/harald/ink-notes"
@@ -39,6 +39,7 @@ sha2 = "0.10"
 ureq = { version = "2.10", default-features = false, features = ["tls", "gzip", "json"] }
 url = "2.5"
 octotablet = "0.1.0"
+minisign-verify = "0.3.0"
 fs2 = "0.4"

 [profile.dev]
@@ -71,7 +71,7 @@ Eine latenzoptimierte, hardwarebeschleunigte Inking- und Notizbuch-Anwendung fü

 - **Natives .deb-Paket**: Optimiert für Zorin OS 18 (Ubuntu 24.04 LTS Basis) mit vollständiger XDG Desktop-Integration (`.desktop`, Hicolor-Icons SVG & PNG, AppStream Metainfo, Debian Copyright & Changelog).
 - **Portables .AppImage**: Eigenständiges x86_64 Bundle.
- **In-App Updater (`src/updater.rs`)**: Automatischer Prüflauf gegen Gitea Releases, SemVer-Filterung, SHA-256-Prüfung und atomarer In-Place Austausch.
+- **In-App Updater (`src/updater.rs`)**: Automatischer Prüflauf gegen Gitea Releases, SemVer-Filterung, Minisign-Signaturprüfung, SHA-256-Prüfung und atomarer In-Place Austausch.

 ### 1. Release-Pakete bauen

@@ -84,6 +84,23 @@ Ergebnis in `target/`:
 - `ink-notes_0.1.0_amd64.deb`
 - `ink-notes_0.1.0_x86_64.AppImage`
 - `SHA256SUMS.txt`
+- `SHA256SUMS.txt.minisig` (nur mit gesetztem `MINISIGN_SECRET_KEY`, siehe unten)
+
+### Release-Signatur einrichten (einmalig)
+
+In-App-Updates werden nur mit gültiger Minisign-Signatur installiert. Signiert wird mit [rsign2](https://crates.io/crates/rsign2), einer Minisign-kompatiblen Implementierung (`cargo install rsign2 --locked`). Einmalig ein Schlüsselpaar erzeugen (ohne Passwort, da es nur als CI-Secret verwendet wird):
+
+```bash
+rsign generate -W -p ink-notes.pub -s ink-notes.key
+```
+
+> **Wichtig:** Schlüssel und Signierwerkzeug müssen zusammenpassen. `rsign generate -W` verschlüsselt den Schlüssel mit einem leeren Passwort; das `minisign`-CLI (z. B. Ubuntu-Paket 0.11) kann ihn ohne Terminal nicht laden. `build-release.sh` und die CI signieren deshalb mit `rsign`.
+
+1. Die zweite Zeile aus `ink-notes.pub` (beginnt mit `RW`) in `src/updater.rs` als `UPDATE_SIGNING_PUBLIC_KEY` eintragen und committen.
+2. Den kompletten Inhalt von `ink-notes.key` in Gitea unter *Repository → Einstellungen → Actions → Secrets* als `MINISIGN_SECRET_KEY` anlegen.
+3. `ink-notes.key` sicher offline aufbewahren und vom Rechner löschen. Geht der Schlüssel verloren, können bestehende Installationen keine Updates mehr prüfen.
+
+Lokal signiert `build-release.sh` nur, wenn `MINISIGN_SECRET_KEY` gesetzt und `rsign` installiert ist. In der CI ist die Signatur Pflicht (`INK_NOTES_REQUIRE_SIGNATURE=1`), und das Skript prüft, dass der geheime Schlüssel zum eingebauten öffentlichen Schlüssel passt.

 ### 2. Installation auf Zorin OS 18 / Ubuntu 24.04

@@ -123,15 +140,15 @@ export GITEA_TOKEN="<DEIN_GITEA_TOKEN>"

 Der In-App-Updater (`src/updater.rs`) folgt strengen Sicherheitsrichtlinien:

-1. **SHA-256-Integritätsprüfung:**
-   - Vor jeder Ausführung oder Installation wird die offizielle Prüfsummendatei `SHA256SUMS.txt` aus dem Release bezogen.
-   - Der SHA-256-Hash des heruntergeladenen Pakets wird berechnet (`sha2`).
+1. **Minisign-Signatur (Pflicht):**
+   - Jedes Release enthält `SHA256SUMS.txt.minisig`, eine Minisign-Signatur der Prüfsummendatei.
+   - Der Updater lädt `SHA256SUMS.txt` und die Signatur **vor** dem Paket und prüft sie gegen den in die App eingebauten öffentlichen Schlüssel (`UPDATE_SIGNING_PUBLIC_KEY` in `src/updater.rs`, Crate `minisign-verify`).
+   - Fehlt die Signatur, ist sie ungültig oder ist kein Schlüssel eingebaut, wird das Update abgelehnt. Ein kompromittierter Release-Server kann so keine manipulierten Pakete ausliefern.
+2. **SHA-256-Integritätsprüfung:**
+   - Der SHA-256-Hash des heruntergeladenen Pakets wird mit dem Eintrag in der signierten `SHA256SUMS.txt` verglichen (`sha2`).
   - Weicht die Prüfsumme ab oder fehlt ein Eintrag, wird die Datei sofort gelöscht und der Installationsvorgang mit Fehlermeldung abgebrochen.
-   - *Hinweis zur Authentizität:* Eine Prüfsumme vom selben Release-Server garantiert Schutz gegen Übertragungsfehler und Datei-Beschädigungen, jedoch keine kryptografische Nicht-Abstreitbarkeit gegenüber einem kompromittierten Server.
-2. **Signatur-Ausblick:**
-   - Die Updater-Architektur enthält Schnittstellen für optionale `.sig`/`.minisig`-Signaturen zur zukünftigen End-to-End-Kryptoverifikation über öffentliche Schlüssel.
 3. **Redirect-Schutz & HTTPS:**
-   - Alle API- und Download-Endpunkte erzwingen standardmäßig HTTPS.
+   - Jede Anfrage erzwingt HTTPS – auch Download-Links aus der Release-API und jedes Weiterleitungsziel.
   - Bei HTTP-Redirects werden sensible Autorisierungs-Header (`Authorization: token ...`) verworfen, sobald die Weiterleitung auf eine andere Origin oder ein externes CDN verweist.
 4. **Isolierter Download-Pfad & Path-Traversal-Schutz:**
   - Downloads werden in einem isolierten Benutzerverzeichnis abgelegt (`$XDG_CACHE_HOME/ink-notes/updates` bzw. `~/.cache/ink-notes/updates`, Berechtigung `0700`).
@@ -3,12 +3,17 @@
 Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux (Zorin OS 18 / Ubuntu 24.04).

 ### Highlights:
+- **Wichtige Fehlerbehebung**: Nach einem Neustart auf einer späteren Seite konnte Weiterschreiben den bisherigen Inhalt dieser Seite überschreiben (betrifft v0.2.3 – v0.3.2)
+- **Neue Werkzeugleiste**: Schmale senkrechte Leiste mit Symbol-Knöpfen, links oder rechts andockbar; selten genutzte Funktionen im ☰-Menü, das Blatt wird daneben zentriert
+- **Einheitliche Dialoge**: Deckende Fenster ohne doppelte Titel, Seitenauswahl mit Vorschaubildern, größere Bedienelemente in allen Popovern
+- **UI per Stift und Touch bedienbar**: Werkzeugleiste, Popover und Dialoge reagieren jetzt auch auf Stift und Finger, auch bei Display-Skalierung
 - **Aktive Stylus-Unterstützung (Lazarite / MPP / AES)**: Natives Wayland-Tablet-Protokoll mit präziser Druck- und Neigungserfassung
 - **Touchscreen Multi-Touch**: Stufenloses 2-Finger Pinch-to-Zoom und Panning mit umschaltbarem Finger-Zeichenmodus
 - **Zwei-Stufen-Inking-Modell**: Kausale Echtzeit-Glättung via 1€-Filter & akausale Ecken-Erhaltung (Corner Preservation)
 - **Geometrie- und Formerkennung**: Geraden, Rechtecke, Kreise, Rauten, Polygone & Koordinatensysteme (Draw-and-Hold)
- **Multi-Dokumenten-Manager**: Unbegrenzte Notizbücher mit atomarem Autosave
- **In-App Updater**: Automatische Versionsprüfung und sichere Atomar-Aktualisierung via Gitea Releases
+- **Multi-Dokumenten-Manager**: Unbegrenzte Notizbücher mit atomarem Autosave, Papierkorb und fortlaufenden Backups
+- **Datensicherheit**: Versioniertes Dateiformat mit Migration, Quarantäne beschädigter Seiten, Schutz vor Doppelöffnung und Crash-getestetem Speichern
+- **In-App Updater**: Automatische Versionsprüfung und sichere Atomar-Aktualisierung via Gitea Releases – mit Pflicht-Signaturprüfung (Minisign) und durchgängigem HTTPS
 - **Vektor-PDF-Export**: Verlustfreie Ausgabe für Druck und Weitergabe

 ### Installation:
@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # ==============================================================================
 # Haupt-Release-Build-Skript für ink-notes (Zorin OS 18 / Linux)
-# Erstellt .deb, .AppImage und SHA256-Prüfsummen in target/
+# Erstellt .deb, .AppImage, SHA256-Prüfsummen und deren Minisign-Signatur in target/
 # ==============================================================================
 set -euo pipefail

@@ -30,10 +30,51 @@ echo "=== Berechne SHA256-Prüfsummen in target/${CHECKSUM_FILE} ==="
 cd "${ROOT_DIR}/target"
 sha256sum "${DEB_NAME}" "${APPIMAGE_NAME}" > "${CHECKSUM_FILE}"

+# 4. Prüfsummen signieren (Pflicht für In-App-Updates)
+# Signiert wird mit rsign2 (minisign-kompatibles Format): Der Schlüssel wurde mit
+# `rsign generate -W` erzeugt; das minisign-CLI kann ihn ohne Terminal nicht laden.
+SIGNATURE_FILE="${CHECKSUM_FILE}.minisig"
+rm -f "${SIGNATURE_FILE}"
+# Schlüssel kann von rustfmt in die Folgezeile umgebrochen sein
+EMBEDDED_PUBKEY=$(grep -m1 -A1 'pub const UPDATE_SIGNING_PUBLIC_KEY' "${ROOT_DIR}/src/updater.rs" | grep -o '"[^"]*"' | head -n1 | tr -d '"')
+if [ -n "${MINISIGN_SECRET_KEY:-}" ]; then
+    if [ -z "${EMBEDDED_PUBKEY}" ]; then
+        echo "FEHLER: UPDATE_SIGNING_PUBLIC_KEY in src/updater.rs ist leer – diese Version könnte keine Updates prüfen."
+        exit 1
+    fi
+    if ! command -v rsign >/dev/null 2>&1; then
+        echo "FEHLER: rsign nicht gefunden (Installation: cargo install rsign2 --locked)."
+        exit 1
+    fi
+    echo "=== Signiere ${CHECKSUM_FILE} mit rsign2 ==="
+    KEY_FILE="$(mktemp)"
+    trap 'rm -f "${KEY_FILE}"' EXIT
+    printf '%s\n' "${MINISIGN_SECRET_KEY}" > "${KEY_FILE}"
+    rsign sign -W -s "${KEY_FILE}" -t "ink-notes v${VERSION}" -x "${SIGNATURE_FILE}" "${CHECKSUM_FILE}"
+    rm -f "${KEY_FILE}"
+    # Stellt sicher, dass der geheime Schlüssel zum eingebauten öffentlichen Schlüssel passt
+    # rsign beendet sich bei falscher Key-ID mit Exit-Code 0, daher zusätzlich die Meldung prüfen
+    if ! VERIFY_OUT=$(rsign verify -P "${EMBEDDED_PUBKEY}" -x "${SIGNATURE_FILE}" "${CHECKSUM_FILE}" 2>&1) \
+        || ! grep -q "Signature and comment signature verified" <<<"${VERIFY_OUT}"; then
+        echo "${VERIFY_OUT}"
+        echo "FEHLER: Signatur passt nicht zum eingebauten öffentlichen Schlüssel (UPDATE_SIGNING_PUBLIC_KEY)."
+        rm -f "${SIGNATURE_FILE}"
+        exit 1
+    fi
+    echo "${VERIFY_OUT}"
+elif [ "${INK_NOTES_REQUIRE_SIGNATURE:-0}" = "1" ]; then
+    echo "FEHLER: MINISIGN_SECRET_KEY ist nicht gesetzt, eine Signatur ist aber Pflicht."
+    exit 1
+else
+    echo "WARNUNG: MINISIGN_SECRET_KEY nicht gesetzt – ${CHECKSUM_FILE} bleibt unsigniert."
+    echo "         Installierte Apps lehnen ein solches Release als Update ab."
+fi
+
 echo "======================================================================"
 echo "Release-Artefakte für v${VERSION} erfolgreich erstellt:"
 echo "======================================================================"
 ls -lh "${DEB_NAME}" "${APPIMAGE_NAME}" "${CHECKSUM_FILE}"
+if [ -f "${SIGNATURE_FILE}" ]; then ls -lh "${SIGNATURE_FILE}"; fi
 echo ""
 echo "Inhalt von target/${CHECKSUM_FILE}:"
 cat "${CHECKSUM_FILE}"
@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # ==============================================================================
 # Veröffentlicht ein Release auf dem Gitea-Server (gitea.pansi.eu)
-# Lädt .deb, .AppImage und SHA256SUMS.txt idempotent als Release-Assets hoch.
+# Lädt .deb, .AppImage, SHA256SUMS.txt und SHA256SUMS.txt.minisig idempotent als Release-Assets hoch.
 # ==============================================================================
 set -euo pipefail

@@ -33,6 +33,7 @@ RELEASE_TITLE="ink-notes ${TAG_NAME}"
 DEB_FILE="${ROOT_DIR}/target/ink-notes_${VERSION}_amd64.deb"
 APPIMAGE_FILE="${ROOT_DIR}/target/ink-notes_${VERSION}_x86_64.AppImage"
 CHECKSUMS_FILE="${ROOT_DIR}/target/SHA256SUMS.txt"
+SIGNATURE_FILE="${CHECKSUMS_FILE}.minisig"
 TEMPLATE_FILE="${ROOT_DIR}/packaging/release-notes.md.tmpl"

 if [ ! -f "${TEMPLATE_FILE}" ]; then
@@ -46,6 +47,12 @@ if [ ! -f "${DEB_FILE}" ] || [ ! -f "${APPIMAGE_FILE}" ] || [ ! -f "${CHECKSUMS_
    "${SCRIPT_DIR}/build-release.sh"
 fi

+# Ohne Signatur lehnen installierte Apps das Release als Update ab
+if [ ! -f "${SIGNATURE_FILE}" ]; then
+    echo "FEHLER: '${SIGNATURE_FILE}' fehlt. Release mit gesetztem MINISIGN_SECRET_KEY bauen."
+    exit 1
+fi
+
 echo "======================================================================"
 echo "Veröffentliche Release ${TAG_NAME} auf ${GITEA_SERVER}/${REPO_OWNER}/${REPO_NAME}"
 echo "======================================================================"
@@ -230,6 +237,7 @@ except Exception:
 upload_asset "${DEB_FILE}"
 upload_asset "${APPIMAGE_FILE}"
 upload_asset "${CHECKSUMS_FILE}"
+upload_asset "${SIGNATURE_FILE}"

 echo "======================================================================"
 echo "Release ${TAG_NAME} erfolgreich veröffentlicht!"
@@ -312,7 +312,12 @@ impl AutosaveController {

    /// Markiert eine Seite als geändert und startet/erneuert das Debounce-Fenster.
    pub fn mark_page_dirty(&mut self, page: &Page, manifest: &NotebookManifest) {
-        if self.read_only || page.persist == crate::document::PersistState::ReadOnlyAfterLoadError {
+        // Nicht geladene Platzhalter nie schreiben: Sie sind leer und würden den Inhalt
+        // der Seitendatei überschreiben
+        if self.read_only
+            || !page.is_loaded
+            || page.persist == crate::document::PersistState::ReadOnlyAfterLoadError
+        {
            return;
        }
        let page_data = PageData::from(page);
@@ -330,6 +335,14 @@ impl AutosaveController {
        }
    }

+    /// Gleicht das Manifest (Seitenliste, aktuelle Seite, ID-Zähler) mit dem Notizbuch ab
+    /// und markiert die aktuelle Seite als geändert. So landen auch neu angelegte Seiten
+    /// im gespeicherten Manifest.
+    pub fn mark_dirty(&mut self, notebook: &Notebook, manifest: &mut NotebookManifest) {
+        manifest.sync_from_notebook(notebook);
+        self.mark_page_dirty(notebook.current_page(), manifest);
+    }
+
    /// Markiert das Manifest als geändert (z. B. bei Seitenwechsel oder Umbenennen).
    pub fn mark_manifest_dirty(&mut self, manifest: &NotebookManifest) {
        if self.read_only {
@@ -94,6 +94,9 @@ pub struct CanvasState {
    pub config: wgpu::SurfaceConfiguration,
    pub size: PhysicalSize<u32>,
    pub viewport: PageViewport,
+    /// Von seitlicher UI belegte Breite links/rechts in physischen Pixeln
+    ui_inset_left: f32,
+    ui_inset_right: f32,
    pub camera: crate::viewport::ViewportState,

    // Pipelines
@@ -371,6 +374,8 @@ impl CanvasState {
            config,
            size,
            viewport,
+            ui_inset_left: 0.0,
+            ui_inset_right: 0.0,
            strip_pipeline,
            triangle_pipeline,
            camera_buffer,
@@ -418,6 +423,29 @@ impl CanvasState {
        );
    }

+    /// Setzt die von seitlicher UI belegten Streifen (physische Pixel), damit die Seite
+    /// im freien Bereich zentriert wird. Gibt `true` zurück, wenn sich etwas geändert hat.
+    pub fn set_ui_insets(&mut self, left: f32, right: f32) -> bool {
+        if (self.ui_inset_left - left).abs() < 0.5 && (self.ui_inset_right - right).abs() < 0.5 {
+            return false;
+        }
+        self.ui_inset_left = left;
+        self.ui_inset_right = right;
+        self.recalculate_viewport();
+        true
+    }
+
+    fn recalculate_viewport(&mut self) {
+        self.viewport = PageViewport::calculate_with_insets(
+            self.size.width as f32,
+            self.size.height as f32,
+            Self::VIEWPORT_MARGIN,
+            self.ui_inset_left,
+            self.ui_inset_right,
+        );
+        self.update_uniforms();
+    }
+
    /// Passt die Surface und Projektionsmatrizen an eine neue Fenstergröße an.
    pub fn resize(&mut self, new_size: PhysicalSize<u32>) {
        if new_size.width > 0 && new_size.height > 0 {
@@ -425,14 +453,7 @@ impl CanvasState {
            self.config.width = new_size.width;
            self.config.height = new_size.height;
            self.surface.configure(&self.device, &self.config);
-
-            self.viewport = PageViewport::calculate(
-                new_size.width as f32,
-                new_size.height as f32,
-                Self::VIEWPORT_MARGIN,
-            );
-
-            self.update_uniforms();
+            self.recalculate_viewport();
        }
    }

@@ -772,7 +772,21 @@ pub struct PageViewport {
 impl PageViewport {
    /// Berechnet die zentrierte DIN-A4-Projektionsfläche unter Beibehaltung des 210x297-Seitenverhältnisses.
    pub fn calculate(window_width: f32, window_height: f32, margin: f32) -> Self {
-        let avail_w = (window_width - 2.0 * margin).max(10.0);
+        Self::calculate_with_insets(window_width, window_height, margin, 0.0, 0.0)
+    }
+
+    /// Wie [`Self::calculate`], aber ohne die von seitlicher UI (z. B. Werkzeugleiste)
+    /// belegten Streifen links/rechts: Die Seite wird im verbleibenden Bereich zentriert.
+    pub fn calculate_with_insets(
+        window_width: f32,
+        window_height: f32,
+        margin: f32,
+        inset_left: f32,
+        inset_right: f32,
+    ) -> Self {
+        let inset_left = inset_left.clamp(0.0, window_width * 0.5);
+        let inset_right = inset_right.clamp(0.0, window_width * 0.5);
+        let avail_w = (window_width - inset_left - inset_right - 2.0 * margin).max(10.0);
        let avail_h = (window_height - 2.0 * margin).max(10.0);

        let window_ratio = avail_w / avail_h;
@@ -790,7 +804,7 @@ impl PageViewport {
            (w, h)
        };

-        let page_x = (window_width - page_w) / 2.0;
+        let page_x = inset_left + (window_width - inset_left - inset_right - page_w) / 2.0;
        let page_y = (window_height - page_h) / 2.0;

        Self {
@@ -931,6 +945,25 @@ mod tests {
        assert_eq!(nb.current_page_index, 0);
    }

+    #[test]
+    fn test_viewport_insets_center_page_in_free_area() {
+        // Breites Fenster: Seite wird durch die Höhe begrenzt und im freien Bereich zentriert
+        let plain = PageViewport::calculate(1600.0, 900.0, 20.0);
+        let inset = PageViewport::calculate_with_insets(1600.0, 900.0, 20.0, 120.0, 0.0);
+        assert!((inset.page_width - plain.page_width).abs() < 0.01);
+        let free_center = 120.0 + (1600.0 - 120.0) / 2.0;
+        assert!((inset.page_x + inset.page_width / 2.0 - free_center).abs() < 0.01);
+
+        // Hohes Fenster: Breite begrenzt, Seite wird schmaler und bleibt rechts der Leiste
+        let narrow = PageViewport::calculate_with_insets(600.0, 1200.0, 20.0, 100.0, 0.0);
+        assert!(narrow.page_x >= 100.0 + 20.0 - 0.01);
+        assert!(narrow.page_x + narrow.page_width <= 600.0 - 20.0 + 0.01);
+
+        // Leiste rechts
+        let right = PageViewport::calculate_with_insets(600.0, 1200.0, 20.0, 0.0, 100.0);
+        assert!(right.page_x + right.page_width <= 500.0 - 20.0 + 0.01);
+    }
+
    #[test]
    fn test_page_viewport_projection() {
        let vp = PageViewport::calculate(1600.0, 900.0, 20.0);
@@ -139,6 +139,16 @@ pub fn generate_pdf_document(
    if notebook.pages.is_empty() {
        return Err("Notizbuch enthält keine Seiten".into());
    }
+    // Nicht geladene Seiten würden sonst stillschweigend als leere Seiten exportiert
+    if let Some(page) = notebook.pages.iter().find(|p| {
+        !p.is_loaded || p.persist == crate::document::PersistState::ReadOnlyAfterLoadError
+    }) {
+        return Err(format!(
+            "Seite {} ist nicht geladen – Export abgebrochen (vorher storage::load_all_pages aufrufen)",
+            page.id
+        )
+        .into());
+    }

    // 1. Erstes Dokument mit Seite 1 erstellen
    let title = "ink-notes Notebook";
@@ -9,6 +9,7 @@ pub mod filter;
 pub mod geometry;
 pub mod history;
 pub mod selection;
+pub mod settings;
 pub mod spline;
 pub mod storage;
 pub mod ui;
@@ -1,6 +1,8 @@
 //! ink-notes: Latenzoptimierte Linux-Inking-App mit wgpu, winit, egui-Toolbar,
 //! Seitenverwaltung, Undo/Redo, Vektor-PDF-Export und asynchroner Notizbuch-Persistenz (Autosave).

+use std::path::{Path, PathBuf};
+use std::sync::mpsc::{self, Sender};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use winit::{
@@ -21,6 +23,7 @@ use ink_notes::geometry::{self, RecognizedShape};
 use ink_notes::selection::{
    render_selection_overlay, DragMode, SelectionHandleHit, SelectionState,
 };
+use ink_notes::settings::{SidebarSide, UiSettings};
 use ink_notes::storage::{self, NotebookManifest};
 use ink_notes::ui::{self, ActiveTool, UiAction, UiState};
 use ink_notes::updater::UpdaterController;
@@ -52,6 +55,44 @@ fn update_window_title(
    window.set_title(&title);
 }

+/// Exportiert das Notizbuch im Hintergrund als PDF. Noch nicht geladene Seiten werden vorher
+/// von der Festplatte nachgeladen; das Ergebnis geht über `result_tx` an den Event-Loop zurück.
+fn start_pdf_export(
+    notebook: &Notebook,
+    storage_dir: &Path,
+    title: &str,
+    result_tx: Sender<Result<PathBuf, String>>,
+    window: Arc<Window>,
+) {
+    let mut notebook_clone = notebook.clone();
+    let storage_dir = storage_dir.to_path_buf();
+    let export_path = export::resolve_pdf_export_path(title);
+    println!(
+        "[Export] Starte PDF-Vektorexport nach '{}' (im Hintergrundthread)...",
+        export_path.display()
+    );
+    std::thread::spawn(move || {
+        let start = Instant::now();
+        let result = storage::load_all_pages(&storage_dir, &mut notebook_clone)
+            .map_err(|err| err.to_string())
+            .and_then(|()| {
+                export_notebook_to_pdf(&notebook_clone, &export_path, ExportStrategy::FilledPolygon)
+                    .map_err(|err| err.to_string())
+            });
+        match &result {
+            Ok(()) => println!(
+                "[Export] PDF erfolgreich exportiert: '{}' ({:.1?} für {} Seiten)",
+                export_path.display(),
+                start.elapsed(),
+                notebook_clone.pages.len()
+            ),
+            Err(err) => eprintln!("[Export-Fehler] Konnte PDF nicht exportieren: {err}"),
+        }
+        let _ = result_tx.send(result.map(|()| export_path));
+        window.request_redraw();
+    });
+}
+
 /// Finalisiert einen Strich (mit Spline-Tessellierung, Ecken-Erkennung & RDP oder Auto-Snap)
 /// und fügt ihn in die aktuelle Seite des Notizbuchs ein.
 fn commit_stroke_to_notebook(
@@ -83,7 +124,7 @@ fn commit_stroke_to_notebook(
        page.add_stroke(stroke);
        canvas.sync_page(page);
        manifest.next_stroke_id = notebook.next_stroke_id;
-        autosave.mark_page_dirty(notebook.current_page(), manifest);
+        autosave.mark_dirty(notebook, manifest);
        update_window_title(
            window,
            notebook,
@@ -125,23 +166,35 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    );
    let available_notebooks = storage::list_notebooks(&storage_base_dir);

-    let (initial_id, initial_title) = if let Some(first) = available_notebooks.first() {
+    // Beschädigte Notizbücher nicht automatisch öffnen
+    let (initial_id, initial_title) = if let Some(first) = available_notebooks
+        .iter()
+        .find(|s| s.status == storage::NotebookStatus::Normal)
+    {
        (first.id.clone(), first.title.clone())
    } else {
        ("default".to_string(), "Standard-Notizbuch".to_string())
    };

    let mut storage_dir = storage_base_dir.join(&initial_id);
+    let mut startup_warning: Option<String> = None;
    let (mut notebook, mut manifest) = if storage_dir.join("manifest.json").exists() {
        println!("[Storage] Lade Notizbuch aus: {}", storage_dir.display());
        match storage::load_notebook(&storage_dir) {
            Ok((nb, m)) => (nb, m),
            Err(err) => {
-                eprintln!("[Storage-Fehler] Konnte Notizbuch nicht laden ({err}). Erstelle neues Notizbuch.");
-                (
-                    Notebook::new(),
-                    NotebookManifest::new(&initial_id, &initial_title),
-                )
+                // Den Ordner des nicht ladbaren Notizbuchs NICHT wiederverwenden, sonst würde
+                // der Autosave dessen Manifest überschreiben und alle Seiten verwaist zurücklassen.
+                eprintln!(
+                    "[Storage-Fehler] Konnte Notizbuch nicht laden ({err}). '{}' bleibt unverändert, erstelle neues Notizbuch.",
+                    storage_dir.display()
+                );
+                startup_warning = Some(format!(
+                    "Notizbuch '{initial_title}' konnte nicht geladen werden – neues Notizbuch angelegt"
+                ));
+                let (nb, m, dir) = storage::create_new_notebook(&storage_base_dir, &initial_title)?;
+                storage_dir = dir;
+                (nb, m)
            }
        }
    } else {
@@ -163,6 +216,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    egui_ctx.set_visuals(egui::Visuals::dark());

    // 4. In-App Gitea Updater initialisieren und im Hintergrund nach Releases fragen
+    // Ergebnisse der PDF-Exporte aus dem Hintergrundthread
+    let (export_tx, export_rx) = mpsc::channel::<Result<PathBuf, String>>();
+
    let mut updater = UpdaterController::new();
    updater.check_for_updates();

@@ -175,9 +231,20 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    );

    let mut ui_state = UiState::new();
+    // Gespeicherte UI-Einstellungen (Seite der Werkzeugleiste)
+    let ui_settings_path = UiSettings::default_path();
+    let mut ui_settings = ui_settings_path
+        .as_deref()
+        .map(UiSettings::load_from)
+        .unwrap_or_default();
+    ui_state.sidebar_side = ui_settings.sidebar_side;
    ui_state.current_notebook_id = manifest.id.clone();
    ui_state.document_title = manifest.title.clone();
    ui_state.available_notebooks = available_notebooks;
+    if let Some(warning) = startup_warning {
+        ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+        ui_state.set_export_message(warning);
+    }
    let mut selection_state = SelectionState::new();

    let mut _notebook_lock = match storage::NotebookLock::acquire(&storage_dir) {
@@ -188,7 +255,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
        Err(storage::StorageError::AlreadyLocked(msg)) => {
            eprintln!("[Storage-Lock] {msg}");
            autosave.set_read_only(true);
-            ui_state.set_export_message("⚠️ In anderer Instanz geöffnet (Schreibschutz)");
+            ui_state.set_export_message("⚠ In anderer Instanz geöffnet (Schreibschutz)");
            None
        }
        Err(e) => {
@@ -216,6 +283,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut active_touches: std::collections::HashMap<u64, (f32, f32)> =
        std::collections::HashMap::new();
    let mut pinch_prev_distance: Option<f32> = None;
+    // Berührungen, die auf der UI begonnen haben, gehören bis zum Abheben egui
+    let mut ui_touch_ids: std::collections::HashSet<u64> = std::collections::HashSet::new();
    let mut pinch_prev_center: Option<(f32, f32)> = None;
    let mut is_pinch_gesturing = false;
    let mut is_touch_drawing = false;
@@ -228,6 +297,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stylus_tool_id: Option<octotablet::tool::ID> = None;
    let mut stylus_barrel_pressed = false;
    let mut stylus_screen_pos = (0.0_f32, 0.0_f32);
+    // Stift hat auf der UI aufgesetzt: alle Ereignisse bis zum Abheben gehen an egui
+    let mut stylus_ui_capture = false;
+    // Von egui angeforderter Zeitpunkt für das nächste Neuzeichnen (Layout-Vermessung, Tooltips)
+    let mut egui_repaint_at: Option<Instant> = None;

    // Viewport-Pan & Zoom-Zustand
    let mut is_panning = false;
@@ -287,6 +360,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                    update_window_title(&window, &notebook, &manifest, ui_state.active_tool, new_status);
                }

+                while let Ok(result) = export_rx.try_recv() {
+                    match result {
+                        Ok(path) => ui_state.set_export_message(format!("PDF gespeichert: {}", path.display())),
+                        Err(err) => ui_state.set_export_message(format!("PDF-Export fehlgeschlagen: {err}")),
+                    }
+                    window.request_redraw();
+                }
+
                let prev_upd = updater.status().clone();
                updater.update();
                if *updater.status() != prev_upd {
@@ -312,6 +393,19 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    octotablet::events::ToolEvent::Out
                                    | octotablet::events::ToolEvent::Removed => {
                                        is_stylus_in_proximity = false;
+                                        if stylus_ui_capture {
+                                            stylus_ui_capture = false;
+                                            let (sx, sy) = stylus_screen_pos;
+                                            let input = egui_winit_state.egui_input_mut();
+                                            input.events.push(egui::Event::PointerButton {
+                                                pos: egui::pos2(sx / scale, sy / scale),
+                                                button: egui::PointerButton::Primary,
+                                                pressed: false,
+                                                modifiers: egui::Modifiers::default(),
+                                            });
+                                            input.events.push(egui::Event::PointerGone);
+                                            window.request_redraw();
+                                        }
                                        if stylus_tool_id == Some(tool.id()) {
                                            stylus_tool_id = None;
                                            if is_stylus_drawing {
@@ -359,6 +453,24 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                            current_pressure = p;
                                        }

+                                        // Stiftbewegung an egui weitergeben (Hover, Schieberegler ziehen),
+                                        // solange nicht auf dem Blatt gezeichnet oder radiert wird
+                                        if stylus_ui_capture || (!is_stylus_drawing && !is_erasing) {
+                                            let ui_pos = egui::pos2(sx / scale, sy / scale);
+                                            egui_winit_state
+                                                .egui_input_mut()
+                                                .events
+                                                .push(egui::Event::PointerMoved(ui_pos));
+                                            if stylus_ui_capture
+                                                || ui::is_screen_point_in_ui(&egui_ctx, &ui_state, (sx, sy), scale)
+                                            {
+                                                window.request_redraw();
+                                            }
+                                        }
+                                        if stylus_ui_capture {
+                                            continue;
+                                        }
+
                                        if is_erasing {
                                            if let Some(page_pt) = canvas.screen_to_page(sx, sy) {
                                                let page = notebook.current_page_mut();
@@ -369,10 +481,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                );
                                                if !removed.is_empty() {
                                                    canvas.sync_page(page);
-                                                    autosave.mark_page_dirty(
-                                                        notebook.current_page(),
-                                                        &manifest,
-                                                    );
+                                                    autosave.mark_dirty(&notebook, &mut manifest);
                                                    update_window_title(
                                                        &window,
                                                        &notebook,
@@ -408,28 +517,19 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                        stylus_tool_id = Some(tool.id());
                                        let (sx, sy) = stylus_screen_pos;

-                                        let is_stylus_in_ui = egui_ctx.wants_pointer_input()
-                                            || ui_state.is_point_in_ui(sx, sy)
-                                            || (ui_state.show_page_jump_popup
-                                                && egui_ctx.is_pointer_over_area())
-                                            || (ui_state.is_document_menu_open
-                                                && egui_ctx.is_pointer_over_area())
-                                            || (ui_state.is_update_dialog_open
-                                                && egui_ctx.is_pointer_over_area());
-
-                                        if is_stylus_in_ui {
-                                            egui_ctx.input_mut(|i| {
-                                                i.events.push(egui::Event::PointerMoved(egui::pos2(
-                                                    sx / scale,
-                                                    sy / scale,
-                                                )));
-                                                i.events.push(egui::Event::PointerButton {
-                                                    pos: egui::pos2(sx / scale, sy / scale),
-                                                    button: egui::PointerButton::Primary,
-                                                    pressed: true,
-                                                    modifiers: egui::Modifiers::default(),
-                                                });
+                                        if ui::is_screen_point_in_ui(&egui_ctx, &ui_state, (sx, sy), scale) {
+                                            // In die Eingabe-Warteschlange des NÄCHSTEN egui-Frames
+                                            // (egui_ctx.input_mut würde vom nächsten Frame überschrieben)
+                                            let ui_pos = egui::pos2(sx / scale, sy / scale);
+                                            let input = egui_winit_state.egui_input_mut();
+                                            input.events.push(egui::Event::PointerMoved(ui_pos));
+                                            input.events.push(egui::Event::PointerButton {
+                                                pos: ui_pos,
+                                                button: egui::PointerButton::Primary,
+                                                pressed: true,
+                                                modifiers: egui::Modifiers::default(),
                                            });
+                                            stylus_ui_capture = true;
                                            window.request_redraw();
                                            continue;
                                        }
@@ -449,10 +549,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                );
                                                if !removed.is_empty() {
                                                    canvas.sync_page(page);
-                                                    autosave.mark_page_dirty(
-                                                        notebook.current_page(),
-                                                        &manifest,
-                                                    );
+                                                    autosave.mark_dirty(&notebook, &mut manifest);
                                                    update_window_title(
                                                        &window,
                                                        &notebook,
@@ -485,24 +582,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    }
                                    octotablet::events::ToolEvent::Up => {
                                        let (sx, sy) = stylus_screen_pos;
-                                        let is_stylus_in_ui = egui_ctx.wants_pointer_input()
-                                            || ui_state.is_point_in_ui(sx, sy)
-                                            || (ui_state.show_page_jump_popup
-                                                && egui_ctx.is_pointer_over_area())
-                                            || (ui_state.is_document_menu_open
-                                                && egui_ctx.is_pointer_over_area())
-                                            || (ui_state.is_update_dialog_open
-                                                && egui_ctx.is_pointer_over_area());
-
-                                        if is_stylus_in_ui {
-                                            egui_ctx.input_mut(|i| {
-                                                i.events.push(egui::Event::PointerButton {
+                                        if stylus_ui_capture {
+                                            stylus_ui_capture = false;
+                                            egui_winit_state.egui_input_mut().events.push(
+                                                egui::Event::PointerButton {
                                                    pos: egui::pos2(sx / scale, sy / scale),
                                                    button: egui::PointerButton::Primary,
                                                    pressed: false,
                                                    modifiers: egui::Modifiers::default(),
-                                                });
-                                            });
+                                                },
+                                            );
                                            window.request_redraw();
                                            continue;
                                        }
@@ -572,6 +661,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                    }
                }

+                // Von egui angefordertes, verzögertes Neuzeichnen (Tooltips, Animationen)
+                if let Some(at) = egui_repaint_at {
+                    if Instant::now() >= at {
+                        egui_repaint_at = None;
+                        window.request_redraw();
+                    }
+                }
+
                // Bei anstehenden Änderungen, aktivem Toast, Stylus in Proximity oder aktivem Zeichnen regelmäßig aufwachen
                if new_status == AutosaveStatus::Pending
                    || new_status == AutosaveStatus::Saving
@@ -581,6 +678,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                    || is_stylus_in_proximity
                {
                    target.set_control_flow(ControlFlow::wait_duration(Duration::from_millis(8)));
+                } else if let Some(at) = egui_repaint_at {
+                    target.set_control_flow(ControlFlow::WaitUntil(at));
                } else {
                    target.set_control_flow(ControlFlow::Wait);
                }
@@ -596,9 +695,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                // 2. Prüfen, ob das UI Pointer-Interaktionen beansprucht (Event-Isolation)
                // Konsumiert Klicks innerhalb der abgerundeten Pill-Toolbar, des Popovers oder offener Menüs
                let is_pointer_in_ui = egui_ctx.wants_pointer_input()
-                    || ui_state.is_point_in_ui(cursor_screen_pos.0, cursor_screen_pos.1)
-                    || (ui_state.show_page_jump_popup && egui_ctx.is_pointer_over_area())
-                    || (ui_state.is_document_menu_open && egui_ctx.is_pointer_over_area());
+                    || ui::is_screen_point_in_ui(
+                        &egui_ctx,
+                        &ui_state,
+                        cursor_screen_pos,
+                        window.scale_factor() as f32,
+                    );

                match event {
                    WindowEvent::CloseRequested => {
@@ -625,6 +727,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                        is_erasing = false;
                        is_mouse_drawing = false;
                        active_touches.clear();
+                        ui_touch_ids.clear();
+                        stylus_ui_capture = false;
                        is_pinch_gesturing = false;
                        pinch_prev_distance = None;
                        pinch_prev_center = None;
@@ -713,7 +817,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                if notebook.current_page_mut().undo() {
                                    selection_state.clear();
                                    canvas.sync_page(notebook.current_page_mut());
-                                    autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                    autosave.mark_dirty(&notebook, &mut manifest);
                                    update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                    window.request_redraw();
                                }
@@ -727,7 +831,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                if notebook.current_page_mut().redo() {
                                    selection_state.clear();
                                    canvas.sync_page(notebook.current_page_mut());
-                                    autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                    autosave.mark_dirty(&notebook, &mut manifest);
                                    update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                    window.request_redraw();
                                }
@@ -757,7 +861,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                if !new_ids.is_empty() {
                                    canvas.sync_page(notebook.current_page_mut());
                                    manifest.next_stroke_id = notebook.next_stroke_id;
-                                    autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                    autosave.mark_dirty(&notebook, &mut manifest);
                                    ui_state.set_export_message(format!("{} Objekt(e) eingefügt", new_ids.len()));
                                    window.request_redraw();
                                }
@@ -769,7 +873,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    let removed = selection_state.delete_selected(notebook.current_page_mut());
                                    if !removed.is_empty() {
                                        canvas.sync_page(notebook.current_page_mut());
-                                        autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                        autosave.mark_dirty(&notebook, &mut manifest);
                                        ui_state.set_export_message(format!("{} Objekt(e) gelöscht", removed.len()));
                                        window.request_redraw();
                                    }
@@ -801,38 +905,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {

                            // PDF-Export: Strg + E
                            Key::Character(c) if c.eq_ignore_ascii_case("e") && ctrl => {
-                                let notebook_clone = notebook.clone();
-                                let export_path = export::resolve_pdf_export_path(&manifest.title);
-                                let export_path_str = export_path.display().to_string();
-                                let window_ref = window.clone();
-                                println!(
-                                    "[Export] Starte PDF-Vektorexport nach '{}' (im Hintergrundthread)...",
-                                    export_path_str
-                                );
-                                ui_state.set_export_message(format!("PDF gespeichert: {}", export_path.display()));
-                                let export_path_thread = export_path.clone();
-                                std::thread::spawn(move || {
-                                    let start = std::time::Instant::now();
-                                    match export_notebook_to_pdf(
-                                        &notebook_clone,
-                                        &export_path_thread,
-                                        ExportStrategy::FilledPolygon,
-                                    ) {
-                                        Ok(()) => {
-                                            let elapsed = start.elapsed();
-                                            println!(
-                                                "[Export] PDF erfolgreich exportiert: '{}' ({:.1?} für {} Seiten)",
-                                                export_path_thread.display(),
-                                                elapsed,
-                                                notebook_clone.pages.len()
-                                            );
-                                            window_ref.request_redraw();
-                                        }
-                                        Err(err) => {
-                                            eprintln!("[Export-Fehler] Konnte PDF nicht exportieren: {err}");
-                                        }
-                                    }
-                                });
+                                start_pdf_export(&notebook, &storage_dir, &manifest.title, export_tx.clone(), window.clone());
+                                ui_state.set_export_message("PDF-Export läuft…");
                                window.request_redraw();
                            }

@@ -868,7 +942,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    let color = [0.12, 0.12, 0.14, 1.0];
                                    if selection_state.recolor_selected(notebook.current_page_mut(), color) {
                                        canvas.sync_page(notebook.current_page_mut());
-                                        autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                        autosave.mark_dirty(&notebook, &mut manifest);
                                        ui_state.set_export_message("Auswahl auf Schwarz umgefärbt".to_string());
                                        window.request_redraw();
                                    }
@@ -888,7 +962,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    let color = [0.15, 0.35, 0.85, 1.0];
                                    if selection_state.recolor_selected(notebook.current_page_mut(), color) {
                                        canvas.sync_page(notebook.current_page_mut());
-                                        autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                        autosave.mark_dirty(&notebook, &mut manifest);
                                        ui_state.set_export_message("Auswahl auf Blau umgefärbt".to_string());
                                        window.request_redraw();
                                    }
@@ -907,7 +981,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                if !selection_state.is_empty() {
                                    if selection_state.rotate_selected_90_deg(notebook.current_page_mut()) {
                                        canvas.sync_page(notebook.current_page_mut());
-                                        autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                        autosave.mark_dirty(&notebook, &mut manifest);
                                        ui_state.set_export_message("Auswahl um 90° gedreht".to_string());
                                        window.request_redraw();
                                    }
@@ -931,7 +1005,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    PageBackground::Blank => PageBackground::Grid5mm,
                                };
                                canvas.sync_page(page);
-                                autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                autosave.mark_dirty(&notebook, &mut manifest);
                                update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                window.request_redraw();
                            }
@@ -945,8 +1019,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                canvas.sync_page(notebook.current_page_mut());
                                manifest.current_page_index = notebook.current_page_index;
                                manifest.next_page_id = notebook.next_page_id;
+                                manifest.sync_from_notebook(&notebook);
                                autosave.mark_manifest_dirty(&manifest);
-                                autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                autosave.mark_dirty(&notebook, &mut manifest);
                                update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                window.request_redraw();
                            }
@@ -958,8 +1033,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                canvas.sync_page(notebook.current_page_mut());
                                manifest.current_page_index = notebook.current_page_index;
                                manifest.next_page_id = notebook.next_page_id;
+                                manifest.sync_from_notebook(&notebook);
                                autosave.mark_manifest_dirty(&manifest);
-                                autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                autosave.mark_dirty(&notebook, &mut manifest);
                                update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                window.request_redraw();
                            }
@@ -972,8 +1048,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                let _ = storage::ensure_page_loaded(&storage_dir, &mut notebook, curr);
                                canvas.sync_page(notebook.current_page_mut());
                                manifest.current_page_index = notebook.current_page_index;
+                                manifest.sync_from_notebook(&notebook);
                                autosave.mark_manifest_dirty(&manifest);
-                                autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                autosave.mark_dirty(&notebook, &mut manifest);
                                update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                window.request_redraw();
                            }
@@ -986,8 +1063,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                let _ = storage::ensure_page_loaded(&storage_dir, &mut notebook, curr);
                                canvas.sync_page(notebook.current_page_mut());
                                manifest.current_page_index = notebook.current_page_index;
+                                manifest.sync_from_notebook(&notebook);
                                autosave.mark_manifest_dirty(&manifest);
-                                autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                autosave.mark_dirty(&notebook, &mut manifest);
                                update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                window.request_redraw();
                            }
@@ -1000,8 +1078,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                let _ = storage::ensure_page_loaded(&storage_dir, &mut notebook, curr);
                                canvas.sync_page(notebook.current_page_mut());
                                manifest.current_page_index = notebook.current_page_index;
+                                manifest.sync_from_notebook(&notebook);
                                autosave.mark_manifest_dirty(&manifest);
-                                autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                autosave.mark_dirty(&notebook, &mut manifest);
                                update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                window.request_redraw();
                            }
@@ -1090,7 +1169,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                        let removed = page.erase_at(page_pt, eraser_radius, stroke_max_radius);
                                        if !removed.is_empty() {
                                            canvas.sync_page(page);
-                                            autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                            autosave.mark_dirty(&notebook, &mut manifest);
                                            update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                            window.request_redraw();
                                        }
@@ -1101,7 +1180,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    // 2. Objektauswahl & Transformation im Select-Modus
                                    if ui_state.active_tool == ActiveTool::Select {
                                        let screen_vec = Vec2::new(sx, sy);
-                                        let hit = selection_state.hit_test_handles(notebook.current_page(), &canvas, screen_vec);
+                                        let hit = selection_state.hit_test_handles(notebook.current_page(), &canvas, screen_vec, egui_ctx.pixels_per_point());
                                        match hit {
                                            SelectionHandleHit::RotateHandle { center_page } => {
                                                if let Some(page_pt) = canvas.screen_to_page(sx, sy) {
@@ -1188,7 +1267,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                    let new_stroke = geometry::shape_to_stroke(shape, old_id, stroke_color, stroke_width);
                                                    notebook.current_page_mut().replace_stroke(old_id, new_stroke);
                                                    canvas.sync_page(notebook.current_page_mut());
-                                                    autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                                    autosave.mark_dirty(&notebook, &mut manifest);
                                                    ui_state.set_export_message(format!("{shape_name} ausgerichtet! (Undo mit Strg+Z)"));
                                                    window.request_redraw();
                                                    return;
@@ -1245,7 +1324,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                            let final_strokes = notebook.current_page().get_strokes(&selection_state.selected_ids);
                                            if !initial_strokes.is_empty() && !final_strokes.is_empty() && initial_strokes != final_strokes {
                                                notebook.current_page_mut().commit_modified_strokes(initial_strokes, final_strokes);
-                                                autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                                autosave.mark_dirty(&notebook, &mut manifest);
                                            }
                                            window.request_redraw();
                                        }
@@ -1358,7 +1437,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    let removed = page.erase_at(page_pt, eraser_radius, stroke_max_radius);
                                    if !removed.is_empty() {
                                        canvas.sync_page(page);
-                                        autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                        autosave.mark_dirty(&notebook, &mut manifest);
                                        update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                        window.request_redraw();
                                    }
@@ -1433,15 +1512,27 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                            return;
                        }

+                        // Berührungen der UI (egui-winit hat sie bereits an egui weitergegeben)
+                        if ui_touch_ids.contains(&touch.id) {
+                            if matches!(touch.phase, TouchPhase::Ended | TouchPhase::Cancelled) {
+                                ui_touch_ids.remove(&touch.id);
+                            }
+                            window.request_redraw();
+                            return;
+                        }
+
                        match touch.phase {
                            TouchPhase::Started => {
                                // Event-Isolation für Touch-Eingaben
-                                let is_touch_in_ui = egui_ctx.wants_pointer_input()
-                                    || ui_state.is_point_in_ui(tx, ty)
-                                    || (ui_state.show_page_jump_popup && egui_ctx.is_pointer_over_area())
-                                    || (ui_state.is_document_menu_open && egui_ctx.is_pointer_over_area())
-                                    || (ui_state.is_update_dialog_open && egui_ctx.is_pointer_over_area());
+                                let is_touch_in_ui = ui::is_screen_point_in_ui(
+                                    &egui_ctx,
+                                    &ui_state,
+                                    (tx, ty),
+                                    window.scale_factor() as f32,
+                                );
                                if is_touch_in_ui {
+                                    ui_touch_ids.insert(touch.id);
+                                    window.request_redraw();
                                    return;
                                }

@@ -1482,14 +1573,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                let removed = page.erase_at(page_pt, eraser_radius, stroke_max_radius);
                                                if !removed.is_empty() {
                                                    canvas.sync_page(page);
-                                                    autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                                    autosave.mark_dirty(&notebook, &mut manifest);
                                                    update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                                    window.request_redraw();
                                                }
                                            }
                                        } else if ui_state.active_tool == ActiveTool::Select {
                                            let screen_vec = Vec2::new(tx, ty);
-                                            let hit = selection_state.hit_test_handles(notebook.current_page(), &canvas, screen_vec);
+                                            let hit = selection_state.hit_test_handles(notebook.current_page(), &canvas, screen_vec, egui_ctx.pixels_per_point());
                                            match hit {
                                                SelectionHandleHit::RotateHandle { center_page } => {
                                                    if let Some(page_pt) = canvas.screen_to_page(tx, ty) {
@@ -1623,7 +1714,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                            let removed = page.erase_at(page_pt, eraser_radius, stroke_max_radius);
                                            if !removed.is_empty() {
                                                canvas.sync_page(page);
-                                                autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                                autosave.mark_dirty(&notebook, &mut manifest);
                                                update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                                window.request_redraw();
                                            }
@@ -1714,7 +1805,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                let final_strokes = notebook.current_page().get_strokes(&selection_state.selected_ids);
                                                if !initial_strokes.is_empty() && !final_strokes.is_empty() && initial_strokes != final_strokes {
                                                    notebook.current_page_mut().commit_modified_strokes(initial_strokes, final_strokes);
-                                                    autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                                    autosave.mark_dirty(&notebook, &mut manifest);
                                                }
                                                window.request_redraw();
                                            }
@@ -1771,6 +1862,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                        updater.update();
                        let actions = ui::render_ui(&egui_ctx, &mut ui_state, &notebook, autosave.status(), &updater);

+                        // Seite neben der Werkzeugleiste zentrieren (Leistenbreite in physischen Pixeln)
+                        let reserved = ui_state.sidebar_reserved_width() * window.scale_factor() as f32;
+                        let (inset_left, inset_right) = match ui_state.sidebar_side {
+                            SidebarSide::Left => (reserved, 0.0),
+                            SidebarSide::Right => (0.0, reserved),
+                        };
+                        if canvas.set_ui_insets(inset_left, inset_right) {
+                            window.request_redraw();
+                        }
+
                        // 4. UI-Aktionen verarbeiten
                        for action in actions {
                            match action {
@@ -1798,7 +1899,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    if !selection_state.is_empty()
                                        && selection_state.recolor_selected(notebook.current_page_mut(), color) {
                                            canvas.sync_page(notebook.current_page_mut());
-                                            autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                            autosave.mark_dirty(&notebook, &mut manifest);
                                            ui_state.set_export_message("Auswahl umgefärbt".to_string());
                                        }
                                    match ui_state.active_tool {
@@ -1833,7 +1934,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                        let removed = selection_state.delete_selected(notebook.current_page_mut());
                                        if !removed.is_empty() {
                                            canvas.sync_page(notebook.current_page_mut());
-                                            autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                            autosave.mark_dirty(&notebook, &mut manifest);
                                            ui_state.set_export_message(format!("{} Objekt(e) gelöscht", removed.len()));
                                            window.request_redraw();
                                        }
@@ -1860,7 +1961,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    if !new_ids.is_empty() {
                                        canvas.sync_page(notebook.current_page_mut());
                                        manifest.next_stroke_id = notebook.next_stroke_id;
-                                        autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                        autosave.mark_dirty(&notebook, &mut manifest);
                                        ui_state.set_export_message(format!("{} Objekt(e) eingefügt", new_ids.len()));
                                        window.request_redraw();
                                    }
@@ -1869,7 +1970,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    if !selection_state.is_empty()
                                        && selection_state.rotate_selected_90_deg(notebook.current_page_mut()) {
                                            canvas.sync_page(notebook.current_page_mut());
-                                            autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                            autosave.mark_dirty(&notebook, &mut manifest);
                                            ui_state.set_export_message("Auswahl um 90° gedreht".to_string());
                                            window.request_redraw();
                                        }
@@ -1897,7 +1998,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    if notebook.current_page_mut().undo() {
                                        selection_state.clear();
                                        canvas.sync_page(notebook.current_page_mut());
-                                        autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                        autosave.mark_dirty(&notebook, &mut manifest);
                                        update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                        window.request_redraw();
                                    }
@@ -1906,7 +2007,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    if notebook.current_page_mut().redo() {
                                        selection_state.clear();
                                        canvas.sync_page(notebook.current_page_mut());
-                                        autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                        autosave.mark_dirty(&notebook, &mut manifest);
                                        update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                        window.request_redraw();
                                    }
@@ -1918,8 +2019,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    let _ = storage::ensure_page_loaded(&storage_dir, &mut notebook, curr);
                                    canvas.sync_page(notebook.current_page_mut());
                                    manifest.current_page_index = notebook.current_page_index;
+                                    manifest.sync_from_notebook(&notebook);
                                    autosave.mark_manifest_dirty(&manifest);
-                                    autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                    autosave.mark_dirty(&notebook, &mut manifest);
                                    update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                    window.request_redraw();
                                }
@@ -1939,8 +2041,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                            background: Some(p.background),
                                        })
                                        .collect();
+                                    manifest.sync_from_notebook(&notebook);
                                    autosave.mark_manifest_dirty(&manifest);
-                                    autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                    autosave.mark_dirty(&notebook, &mut manifest);
                                    update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                    window.request_redraw();
                                }
@@ -1959,11 +2062,22 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                        })
                                        .collect();
                                    canvas.sync_page(notebook.current_page_mut());
+                                    manifest.sync_from_notebook(&notebook);
                                    autosave.mark_manifest_dirty(&manifest);
-                                    autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                    autosave.mark_dirty(&notebook, &mut manifest);
                                    update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                    window.request_redraw();
                                }
+                                UiAction::LoadAllPages => {
+                                    // Für die Vorschaubilder der Seitenauswahl; Fehler werden wie beim
+                                    // Blättern behandelt (Ersatzseite, Warnung beim Öffnen der Seite)
+                                    for idx in 0..notebook.pages.len() {
+                                        if !notebook.pages[idx].is_loaded {
+                                            let _ = storage::ensure_page_loaded(&storage_dir, &mut notebook, idx);
+                                        }
+                                    }
+                                    window.request_redraw();
+                                }
                                UiAction::GoToPage(idx) => {
                                    if idx < notebook.pages.len() {
                                        selection_state.clear();
@@ -1971,8 +2085,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                        let _ = storage::ensure_page_loaded(&storage_dir, &mut notebook, idx);
                                        canvas.sync_page(notebook.current_page_mut());
                                        manifest.current_page_index = idx;
+                                        manifest.sync_from_notebook(&notebook);
                                        autosave.mark_manifest_dirty(&manifest);
-                                        autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                        autosave.mark_dirty(&notebook, &mut manifest);
                                        update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                        window.request_redraw();
                                    }
@@ -1981,43 +2096,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    let page = notebook.current_page_mut();
                                    page.background = bg;
                                    canvas.sync_page(page);
-                                    autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                    autosave.mark_dirty(&notebook, &mut manifest);
                                    update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                    window.request_redraw();
                                }
                                UiAction::ExportPdf => {
-                                    let notebook_clone = notebook.clone();
-                                    let export_path = export::resolve_pdf_export_path(&manifest.title);
-                                    let export_path_str = export_path.display().to_string();
-                                    let window_ref = window.clone();
-                                    println!(
-                                        "[Export] Starte PDF-Vektorexport nach '{}' (im Hintergrundthread)...",
-                                        export_path_str
-                                    );
-                                    ui_state.set_export_message(format!("PDF gespeichert: {}", export_path.display()));
-                                    let export_path_thread = export_path.clone();
-                                    std::thread::spawn(move || {
-                                        let start = std::time::Instant::now();
-                                        match export_notebook_to_pdf(
-                                            &notebook_clone,
-                                            &export_path_thread,
-                                            ExportStrategy::FilledPolygon,
-                                        ) {
-                                            Ok(()) => {
-                                                let elapsed = start.elapsed();
-                                                println!(
-                                                    "[Export] PDF erfolgreich exportiert: '{}' ({:.1?} für {} Seiten)",
-                                                    export_path_thread.display(),
-                                                    elapsed,
-                                                    notebook_clone.pages.len()
-                                                );
-                                                window_ref.request_redraw();
-                                            }
-                                            Err(err) => {
-                                                eprintln!("[Export-Fehler] Konnte PDF nicht exportieren: {err}");
-                                            }
-                                        }
-                                    });
+                                    start_pdf_export(&notebook, &storage_dir, &manifest.title, export_tx.clone(), window.clone());
+                                    ui_state.set_export_message("PDF-Export läuft…");
                                    window.request_redraw();
                                }

@@ -2043,7 +2128,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                        eprintln!("[Storage-Lock] {msg}");
                                                        _notebook_lock = None;
                                                        autosave.set_read_only(true);
-                                                        ui_state.set_export_message("⚠️ In anderer Instanz geöffnet (Schreibschutz)");
+                                                        ui_state.set_export_message("⚠ In anderer Instanz geöffnet (Schreibschutz)");
                                                    }
                                                    Err(e) => {
                                                        eprintln!("[Storage-Lock] Konnte Lock nicht erwerben: {e}");
@@ -2107,6 +2192,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                            Ok(()) => {
                                                ui_state.document_title = manifest.title.clone();
                                                ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+                                                manifest.sync_from_notebook(&notebook);
                                                autosave.mark_manifest_dirty(&manifest);
                                                update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                                ui_state.set_export_message(format!("Umbenannt in '{}'", new_title));
@@ -2265,7 +2351,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    if let Some(page) = notebook.pages.iter_mut().find(|p| p.id == page_id) {
                                        page.unlock_after_load_error();
                                    }
-                                    autosave.mark_page_dirty(notebook.current_page(), &manifest);
+                                    autosave.mark_dirty(&notebook, &mut manifest);
                                    window.request_redraw();
                                }
                                UiAction::RetryShutdown => {
@@ -2301,6 +2387,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                        }
                                    }
                                }
+                                UiAction::SetSidebarSide(side) => {
+                                    ui_settings.sidebar_side = side;
+                                    if let Some(path) = ui_settings_path.as_deref() {
+                                        if let Err(err) = ui_settings.save_to(path) {
+                                            eprintln!("[Einstellungen] Konnte '{}' nicht speichern: {err}", path.display());
+                                            ui_state.set_export_message(format!("Einstellung nicht gespeichert: {err}"));
+                                        }
+                                    }
+                                    window.request_redraw();
+                                }
                                UiAction::ForceExit => {
                                    println!("[Shutdown] Beenden erzwungen trotz ungespeicherter Änderungen.");
                                    target.exit();
@@ -2312,6 +2408,22 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                        let full_output = egui_ctx.end_frame();
                        egui_winit_state.handle_platform_output(&window, full_output.platform_output);

+                        // egui braucht Folge-Frames, z. B. um neu angeordnete Bereiche zu vermessen
+                        // (die Werkzeugleiste wird erst im 2.–3. Frame korrekt zentriert)
+                        let repaint_delay = full_output
+                            .viewport_output
+                            .get(&egui::ViewportId::ROOT)
+                            .map(|v| v.repaint_delay)
+                            .unwrap_or(Duration::MAX);
+                        if repaint_delay.is_zero() {
+                            egui_repaint_at = None;
+                            window.request_redraw();
+                        } else if repaint_delay < Duration::from_secs(10) {
+                            egui_repaint_at = Some(Instant::now() + repaint_delay);
+                        } else {
+                            egui_repaint_at = None;
+                        }
+
                        let clipped_primitives = egui_ctx.tessellate(full_output.shapes, egui_ctx.pixels_per_point());
                        let screen_descriptor = egui_wgpu::ScreenDescriptor {
                            size_in_pixels: [canvas.size.width, canvas.size.height],
@@ -115,12 +115,15 @@ impl SelectionState {
        Page::selection_aabb(&strokes)
    }

-    /// Führt Hit-Testing auf die Auswahlgriffe (Drehen, Ecken, Körper) in Bildschirmkoordinaten durch.
+    /// Führt Hit-Testing auf die Auswahlgriffe (Drehen, Ecken, Körper) in Bildschirmkoordinaten
+    /// (physische Pixel) durch. Abstände und Trefferradien sind in logischen Punkten festgelegt
+    /// und werden mit `pixels_per_point` skaliert, damit sie zur gezeichneten Überlagerung passen.
    pub fn hit_test_handles(
        &self,
        page: &Page,
        canvas: &CanvasState,
        screen_pos: Vec2,
+        pixels_per_point: f32,
    ) -> SelectionHandleHit {
        let Some(aabb) = self.get_selection_aabb(page) else {
            return SelectionHandleHit::None;
@@ -134,9 +137,10 @@ impl SelectionState {
        let screen_center = (screen_min + screen_max) * 0.5;
        let page_center = (aabb.min + aabb.max) * 0.5;

-        // 1. Drehgriff testen (26 px oberhalb des oberen Randes)
-        let rot_screen = Vec2::new(screen_center.x, screen_min.y - 26.0);
-        if (screen_pos - rot_screen).length() <= 14.0 {
+        // 1. Drehgriff testen (oberhalb des oberen Randes, wie gezeichnet)
+        let ppp = pixels_per_point;
+        let rot_screen = Vec2::new(screen_center.x, screen_min.y - ROTATE_HANDLE_OFFSET * ppp);
+        if (screen_pos - rot_screen).length() <= HANDLE_HIT_RADIUS * ppp {
            return SelectionHandleHit::RotateHandle {
                center_page: page_center,
            };
@@ -164,7 +168,7 @@ impl SelectionState {
        ];

        for i in 0..4 {
-            if (screen_pos - corners_screen[i]).length() <= 12.0 {
+            if (screen_pos - corners_screen[i]).length() <= HANDLE_HIT_RADIUS * ppp {
                return SelectionHandleHit::CornerHandle {
                    corner_idx: i,
                    fixed_corner_page: fixed_corners_page[i],
@@ -273,6 +277,16 @@ impl SelectionState {
 }

 /// Rendert das Auswahl-Overlay (Bounding Box, Ecken, Dreh-Griff, Marquee Box) über egui.
+/// Abstand des Drehgriffs über dem Auswahlrahmen (logische Punkte).
+const ROTATE_HANDLE_OFFSET: f32 = 24.0;
+/// Trefferradius der Griffe (logische Punkte), groß genug für Finger.
+const HANDLE_HIT_RADIUS: f32 = 18.0;
+
+/// Wandelt Fensterpixel (physisch) in egui-Koordinaten (logische Punkte) um.
+fn to_ui(screen: [f32; 2], pixels_per_point: f32) -> egui::Pos2 {
+    egui::pos2(screen[0] / pixels_per_point, screen[1] / pixels_per_point)
+}
+
 pub fn render_selection_overlay(
    ctx: &egui::Context,
    selection: &SelectionState,
@@ -283,6 +297,8 @@ pub fn render_selection_overlay(
        egui::Order::Foreground,
        egui::Id::new("selection_overlay_layer"),
    ));
+    // Fensterpixel sind physisch, egui zeichnet in logischen Punkten
+    let ppp = ctx.pixels_per_point();

    // 1. Wenn aktuell ein Auswahlrahmen gezogen wird (Marquee Box)
    if let DragMode::BoxSelect {
@@ -290,8 +306,8 @@ pub fn render_selection_overlay(
        current_page,
    } = selection.drag_mode
    {
-        let p1 = canvas.page_to_screen(start_page);
-        let p2 = canvas.page_to_screen(current_page);
+        let p1 = to_ui(canvas.page_to_screen(start_page), ppp);
+        let p2 = to_ui(canvas.page_to_screen(current_page), ppp);
        let min_x = p1[0].min(p2[0]);
        let min_y = p1[1].min(p2[1]);
        let max_x = p1[0].max(p2[0]);
@@ -303,14 +319,14 @@ pub fn render_selection_overlay(
        painter.rect_filled(
            rect,
            egui::Rounding::same(4.0_f32),
-            egui::Color32::from_rgba_premultiplied(40, 120, 240, 35),
+            egui::Color32::from_rgba_unmultiplied(40, 120, 240, 35),
        );
        painter.rect_stroke(
            rect,
            egui::Rounding::same(4.0_f32),
            egui::Stroke::new(
                1.5_f32,
-                egui::Color32::from_rgba_premultiplied(80, 160, 255, 220),
+                egui::Color32::from_rgba_unmultiplied(80, 160, 255, 220),
            ),
        );
        return;
@@ -321,8 +337,8 @@ pub fn render_selection_overlay(
        return;
    };

-    let p_min = canvas.page_to_screen(aabb.min);
-    let p_max = canvas.page_to_screen(aabb.max);
+    let p_min = to_ui(canvas.page_to_screen(aabb.min), ppp);
+    let p_max = to_ui(canvas.page_to_screen(aabb.max), ppp);

    let screen_min = egui::pos2(p_min[0].min(p_max[0]), p_min[1].min(p_max[1]));
    let screen_max = egui::pos2(p_min[0].max(p_max[0]), p_min[1].max(p_max[1]));
@@ -338,7 +354,7 @@ pub fn render_selection_overlay(

    // Dreh-Stängel (Stalk) und Drehgriff
    let top_center = egui::pos2(rect.center().x, rect.min.y);
-    let rot_handle = egui::pos2(rect.center().x, rect.min.y - 24.0_f32);
+    let rot_handle = egui::pos2(rect.center().x, rect.min.y - ROTATE_HANDLE_OFFSET);

    painter.line_segment(
        [top_center, rot_handle],
@@ -0,0 +1,84 @@
+//! Persistente UI-Einstellungen (`$XDG_CONFIG_HOME/ink-notes/ui.json`).
+//!
+//! Fehlende oder unlesbare Dateien führen zu Standardwerten, damit die App immer startet.
+
+use std::path::{Path, PathBuf};
+
+use serde::{Deserialize, Serialize};
+
+use crate::storage::{self, StorageError};
+
+/// Fensterseite, an der die Werkzeugleiste angedockt ist.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub enum SidebarSide {
+    /// Links (Standard: die Schreibhand von Rechtshändern verdeckt die Leiste nicht)
+    #[default]
+    Left,
+    /// Rechts (für Linkshänder)
+    Right,
+}
+
+/// Benutzereinstellungen der Oberfläche.
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+#[serde(default)]
+pub struct UiSettings {
+    pub sidebar_side: SidebarSide,
+}
+
+impl UiSettings {
+    /// Standardpfad gemäß XDG-Spezifikation.
+    pub fn default_path() -> Option<PathBuf> {
+        let base = match std::env::var("XDG_CONFIG_HOME") {
+            Ok(dir) if !dir.trim().is_empty() => PathBuf::from(dir),
+            _ => PathBuf::from(std::env::var("HOME").ok()?).join(".config"),
+        };
+        Some(base.join("ink-notes").join("ui.json"))
+    }
+
+    /// Lädt die Einstellungen; bei fehlender oder beschädigter Datei gelten Standardwerte.
+    pub fn load_from(path: &Path) -> Self {
+        match std::fs::read_to_string(path) {
+            Ok(content) => serde_json::from_str(&content).unwrap_or_else(|e| {
+                eprintln!(
+                    "[Einstellungen] '{}' ist ungültig ({e}), verwende Standardwerte.",
+                    path.display()
+                );
+                Self::default()
+            }),
+            Err(_) => Self::default(),
+        }
+    }
+
+    /// Speichert die Einstellungen atomar.
+    pub fn save_to(&self, path: &Path) -> Result<(), StorageError> {
+        storage::atomic_write_json(path, self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_settings_round_trip_and_fallbacks() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("ink-notes").join("ui.json");
+
+        // Fehlende Datei -> Standard (links)
+        assert_eq!(UiSettings::load_from(&path).sidebar_side, SidebarSide::Left);
+
+        let settings = UiSettings {
+            sidebar_side: SidebarSide::Right,
+        };
+        settings.save_to(&path).unwrap();
+        assert_eq!(UiSettings::load_from(&path), settings);
+
+        // Beschädigte Datei -> Standard statt Absturz
+        std::fs::write(&path, b"{ kaputt").unwrap();
+        assert_eq!(UiSettings::load_from(&path), UiSettings::default());
+
+        // Unbekannte / fehlende Felder werden toleriert
+        std::fs::write(&path, br#"{"zukunft": 1}"#).unwrap();
+        assert_eq!(UiSettings::load_from(&path), UiSettings::default());
+    }
+}
@@ -697,6 +697,15 @@ pub fn load_notebook(notebook_dir: &Path) -> Result<(Notebook, NotebookManifest)
    );
    notebook.load_warnings = load_warnings;

+    // Die zuletzt geöffnete Seite sofort laden: Sie ist nach dem Start die aktuelle Seite,
+    // und ein leerer Platzhalter würde beim Weiterschreiben ihren Inhalt überschreiben.
+    let current = notebook.current_page_index;
+    if !notebook.pages[current].is_loaded {
+        if let Err(e) = ensure_page_loaded(notebook_dir, &mut notebook, current) {
+            eprintln!("[Storage] Aktuelle Seite {current} konnte nicht geladen werden: {e}");
+        }
+    }
+
    Ok((notebook, manifest))
 }

@@ -1206,6 +1215,28 @@ pub fn cleanup_trash(base_dir: &Path, max_age: std::time::Duration) -> io::Resul
    Ok(removed)
 }

+/// Lädt alle noch nicht geladenen Seiten ohne Ersatzseiten (z. B. für den PDF-Export).
+/// Schlägt fehl, sobald eine Seite nicht vollständig verfügbar ist.
+pub fn load_all_pages(notebook_dir: &Path, notebook: &mut Notebook) -> Result<(), StorageError> {
+    for page in &mut notebook.pages {
+        if page.persist == crate::document::PersistState::ReadOnlyAfterLoadError {
+            return Err(StorageError::CorruptedPage(
+                page.id,
+                "Seite konnte nicht geladen werden".to_string(),
+            ));
+        }
+        if !page.is_loaded {
+            *page = match load_page(notebook_dir, page.id) {
+                Ok(data) => data.to_page(),
+                // Wie beim Lazy Loading: nie gespeicherte Seite = leere Seite
+                Err(StorageError::PageNotFound(_)) => Page::new(page.id, page.background),
+                Err(e) => return Err(e),
+            };
+        }
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -1500,12 +1531,6 @@ mod tests {
    #[cfg(unix)]
    fn test_io_error_does_not_quarantine_and_does_not_overwrite() {
        use crate::document::PersistState;
-        use std::os::unix::fs::PermissionsExt;
-
-        // Skip test if running as root
-        if std::env::var("USER").unwrap_or_default() == "root" {
-            return;
-        }

        let temp_dir = tempfile::tempdir().expect("tempdir");
        let path = temp_dir.path();
@@ -1513,19 +1538,17 @@ mod tests {
        let manifest = NotebookManifest::new("nb_io", "Test IO");
        save_manifest(path, &manifest).unwrap();

+        // I/O-Fehler simulieren, der auch als root auftritt (CI-Runner laufen oft als root,
+        // dort greift ein chmod 000 nicht): page_1.json ist ein Verzeichnis -> EISDIR beim Lesen
        let original_content = br#"{"id": 1, "background": "Grid5mm", "strokes": []}"#;
-        let page_file = path.join("page_1.json");
-        fs::write(&page_file, original_content).unwrap();
-
-        // Make file unreadable
-        fs::set_permissions(&page_file, fs::Permissions::from_mode(0o000)).unwrap();
+        let page_path = path.join("page_1.json");
+        fs::create_dir(&page_path).unwrap();
+        let marker = page_path.join("original");
+        fs::write(&marker, original_content).unwrap();

        let (nb, mut m) =
            load_notebook(path).expect("load_notebook should succeed with fallback page");

-        // Restore permissions for inspection
-        fs::set_permissions(&page_file, fs::Permissions::from_mode(0o600)).unwrap();
-
        let dir_entries: Vec<String> = fs::read_dir(path)
            .unwrap()
            .flatten()
@@ -1544,10 +1567,15 @@ mod tests {
        );

        save_notebook(path, &nb, &mut m).unwrap();
+
+        assert!(
+            page_path.is_dir(),
+            "Original page path must not be replaced"
+        );
        assert_eq!(
-            fs::read(&page_file).unwrap(),
+            fs::read(&marker).unwrap(),
            original_content,
-            "Original file content must not be overwritten"
+            "Original content must not be overwritten"
        );
    }

@@ -2079,4 +2107,130 @@ mod tests {
            "Kompaktes JSON spart mind. 50% Whitespace"
        );
    }
+
+    /// Hilfsfunktion: Seite mit einem einzelnen Strich.
+    fn page_with_one_stroke(page_id: u64, background: PageBackground) -> Page {
+        let mut page = Page::new(page_id, background);
+        let samples = vec![
+            StylusSample {
+                position: glam::Vec2::new(100.0, 100.0),
+                pressure: 0.5,
+                timestamp: 0.0,
+            },
+            StylusSample {
+                position: glam::Vec2::new(200.0, 150.0),
+                pressure: 0.5,
+                timestamp: 0.05,
+            },
+        ];
+        let vertices = vec![
+            InkVertex::new(100.0, 100.0, [0.0, 0.0, 0.0, 1.0]),
+            InkVertex::new(200.0, 150.0, [0.0, 0.0, 0.0, 1.0]),
+        ];
+        page.add_stroke(Stroke::new(1, samples, vertices, [0.0, 0.0, 0.0, 1.0]));
+        page
+    }
+
+    #[test]
+    fn test_keyboard_new_page_is_recorded_in_manifest() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let (mut notebook, mut manifest, dir) =
+            create_new_notebook(temp_dir.path(), "Neue Seiten").unwrap();
+        let mut autosave = AutosaveController::new(dir.clone(), Duration::from_secs(60));
+
+        // Wie Taste N in main.rs: neue Seite anhängen, Strich darauf, speichern
+        notebook.next_page();
+        let idx = notebook.current_page_index;
+        notebook.pages[idx] = page_with_one_stroke(notebook.pages[idx].id, PageBackground::Lined);
+        autosave.mark_dirty(&notebook, &mut manifest);
+        autosave.flush().unwrap();
+        autosave.shutdown().unwrap();
+
+        let (mut reloaded, reloaded_manifest) = load_notebook(&dir).unwrap();
+        assert_eq!(reloaded_manifest.page_ids(), vec![1, 2]);
+        assert_eq!(
+            reloaded.pages.len(),
+            2,
+            "Neue Seite muss einen Neustart überleben"
+        );
+        ensure_page_loaded(&dir, &mut reloaded, 1).unwrap();
+        assert_eq!(reloaded.pages[1].strokes.len(), 1);
+    }
+
+    #[test]
+    fn test_load_all_pages_for_export() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let (mut notebook, mut manifest, dir) =
+            create_new_notebook(temp_dir.path(), "Export").unwrap();
+        notebook.add_page(PageBackground::Lined);
+        notebook.pages[1] = page_with_one_stroke(notebook.pages[1].id, PageBackground::Lined);
+        save_notebook(&dir, &notebook, &mut manifest).unwrap();
+
+        let (mut loaded, _) = load_notebook(&dir).unwrap();
+        assert!(!loaded.pages[1].is_loaded);
+        // Ohne Nachladen verweigert der Export, statt leere Seiten zu erzeugen
+        assert!(crate::export::generate_pdf_document(&loaded, Default::default()).is_err());
+
+        load_all_pages(&dir, &mut loaded).unwrap();
+        assert_eq!(loaded.pages[1].strokes.len(), 1);
+        assert_eq!(loaded.pages[1].background, PageBackground::Lined);
+        assert!(crate::export::generate_pdf_document(&loaded, Default::default()).is_ok());
+    }
+
+    #[test]
+    fn test_restart_on_later_page_keeps_its_content() {
+        // Regression: Beim Start wurde nur Seite 1 geladen; war zuletzt eine spätere Seite
+        // offen, war sie ein leerer Platzhalter, und Weiterschreiben überschrieb ihren Inhalt.
+        let temp_dir = tempfile::tempdir().unwrap();
+        let (mut notebook, mut manifest, dir) =
+            create_new_notebook(temp_dir.path(), "Neustart").unwrap();
+        notebook.add_page(PageBackground::Lined);
+        notebook.pages[1] = page_with_one_stroke(notebook.pages[1].id, PageBackground::Lined);
+        notebook.current_page_index = 1;
+        save_notebook(&dir, &notebook, &mut manifest).unwrap();
+
+        let (mut loaded, mut loaded_manifest) = load_notebook(&dir).unwrap();
+        assert_eq!(loaded.current_page_index, 1);
+        assert!(
+            loaded.current_page().is_loaded,
+            "aktuelle Seite muss geladen sein"
+        );
+        assert_eq!(loaded.current_page().strokes.len(), 1);
+
+        // Weiterschreiben und speichern darf den bisherigen Inhalt nicht verlieren
+        let extra = page_with_one_stroke(99, PageBackground::Lined).strokes[0].clone();
+        loaded.current_page_mut().strokes.push(extra);
+        let mut autosave = AutosaveController::new(dir.clone(), Duration::from_secs(60));
+        autosave.mark_dirty(&loaded, &mut loaded_manifest);
+        autosave.flush().unwrap();
+        autosave.shutdown().unwrap();
+
+        let (reloaded, _) = load_notebook(&dir).unwrap();
+        assert_eq!(reloaded.current_page().strokes.len(), 2);
+    }
+
+    #[test]
+    fn test_autosave_never_writes_unloaded_placeholder() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let (mut notebook, mut manifest, dir) =
+            create_new_notebook(temp_dir.path(), "Platzhalter").unwrap();
+        notebook.add_page(PageBackground::Lined);
+        notebook.pages[1] = page_with_one_stroke(notebook.pages[1].id, PageBackground::Lined);
+        save_notebook(&dir, &notebook, &mut manifest).unwrap();
+        let page_file = dir.join(format!("page_{}.json", notebook.pages[1].id));
+        let before = fs::read(&page_file).unwrap();
+
+        // Platzhalter (nicht geladen) als aktuelle Seite markieren und speichern
+        let placeholder = Page::new_unloaded(notebook.pages[1].id, PageBackground::Lined);
+        let mut autosave = AutosaveController::new(dir.clone(), Duration::from_secs(60));
+        autosave.mark_page_dirty(&placeholder, &manifest);
+        autosave.flush().unwrap();
+        autosave.shutdown().unwrap();
+
+        assert_eq!(
+            fs::read(&page_file).unwrap(),
+            before,
+            "Seitendatei wurde überschrieben"
+        );
+    }
 }
@@ -7,7 +7,7 @@
 //! - Sichere Asset-Namensbereinigung (Path Traversal Schutz)
 //! - Isolierter Benutzer-Cache-Pfad (`$XDG_CACHE_HOME/ink-notes/updates` mit 0700 Rechten)
 //! - Integritätsprüfung via SHA-256 (`SHA256SUMS.txt`) mit automatischem Löschen ungültiger Dateien
-//! - Erweiterbare Schnittstelle für optionale Signaturprüfung (.sig / .minisig)
+//! - Pflicht-Signaturprüfung der `SHA256SUMS.txt` via Minisign (eingebauter öffentlicher Schlüssel)
 //! - Atomares AppImage-Self-Update via `.new`-Zwischendatei, Backup-Pflicht und atomarem `fs::rename`
 //! - Echtes Fortschritts-Streaming (~10 Updates/s)
 //! - Korrekte SemVer-Prüfung via `semver` Crate (Prerelease-Schutz standardmäßig aktiv)
@@ -313,22 +313,78 @@ pub fn verify_checksum(
    Ok(())
 }

-/// Status einer Signaturverifikation (.sig / .minisig).
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum SignatureVerificationStatus {
-    NotPresent,
-    Verified { signer: String },
-    Failed(String),
+/// Öffentlicher Minisign-Schlüssel (Base64), mit dem die `SHA256SUMS.txt` jedes Releases
+/// signiert sein muss. Ist er leer, lehnt diese Version alle In-App-Updates ab.
+/// Erzeugen: `minisign -G -W -p ink-notes.pub -s ink-notes.key`, dann die zweite Zeile
+/// aus `ink-notes.pub` hier eintragen (siehe README, Abschnitt Release-Signatur).
+pub const UPDATE_SIGNING_PUBLIC_KEY: &str =
+    "RWTZqQ0ZDCn+PHTpqgI8NwjtgtkJk5QyJ0FYHWZlCZtABsXBcdPDv9WI";
+
+/// Name des Prüfsummen-Assets eines Releases.
+pub const CHECKSUMS_ASSET_NAME: &str = "SHA256SUMS.txt";
+/// Name der Minisign-Signatur zu [`CHECKSUMS_ASSET_NAME`].
+pub const CHECKSUMS_SIGNATURE_ASSET_NAME: &str = "SHA256SUMS.txt.minisig";
+
+/// Prüft die Minisign-Signatur der Prüfsummendatei. Nur aktuelle (prehashed) Signaturen
+/// werden akzeptiert; ohne hinterlegten Schlüssel schlägt die Prüfung immer fehl.
+pub fn verify_checksums_signature(
+    checksums: &[u8],
+    signature_text: &str,
+    public_key_b64: &str,
+) -> Result<(), String> {
+    let key = public_key_b64.trim();
+    if key.is_empty() {
+        return Err("In dieser Version ist kein Signaturschlüssel für Updates hinterlegt. Bitte das Update manuell installieren.".to_string());
+    }
+    let public_key = minisign_verify::PublicKey::from_base64(key)
+        .map_err(|e| format!("Ungültiger Update-Signaturschlüssel: {e}."))?;
+    let signature = minisign_verify::Signature::decode(signature_text)
+        .map_err(|e| format!("{CHECKSUMS_SIGNATURE_ASSET_NAME} ist ungültig: {e}."))?;
+    public_key
+        .verify(checksums, &signature, false)
+        .map_err(|e| format!("Signaturprüfung von {CHECKSUMS_ASSET_NAME} fehlgeschlagen: {e}."))
 }

-/// Erweiterbare Schnittstelle für kryptografische Signaturprüfung.
-pub fn verify_signature_if_present(
-    _asset_file: &Path,
-    _sig_bytes: Option<&[u8]>,
-) -> Result<SignatureVerificationStatus, String> {
-    // Erweiterungspunkt: Sobald ein Signaturschlüssel / Minisign-Public-Key
-    // im Projekt konfiguriert ist, kann hier die kryptografische Verifikation erfolgen.
-    Ok(SignatureVerificationStatus::NotPresent)
+/// Lädt einen Text-Asset des Releases über den abgesicherten HTTP-Client.
+fn fetch_release_text(
+    agent: &ureq::Agent,
+    release: &GiteaRelease,
+    name: &str,
+    config: &UpdaterConfig,
+) -> Result<String, String> {
+    let asset = release
+        .assets
+        .iter()
+        .find(|a| a.name == name)
+        .ok_or_else(|| format!("Release enthält keine {name}."))?;
+    http_get_with_auth_guard(
+        agent,
+        &asset.browser_download_url,
+        config.auth_token.as_deref(),
+        5,
+        config.allow_insecure_http,
+    )
+    .map_err(|e| format!("Konnte {name} nicht laden: {e}."))?
+    .into_string()
+    .map_err(|e| format!("Konnte {name} nicht dekodieren: {e}."))
+}
+
+/// Lädt `SHA256SUMS.txt` samt Minisign-Signatur und gibt den Inhalt nur bei gültiger
+/// Signatur zurück.
+fn fetch_verified_checksums(
+    agent: &ureq::Agent,
+    release: &GiteaRelease,
+    config: &UpdaterConfig,
+    public_key_b64: &str,
+) -> Result<String, String> {
+    // Ohne Schlüssel gar nicht erst Netzwerkanfragen stellen
+    if public_key_b64.trim().is_empty() {
+        return verify_checksums_signature(b"", "", public_key_b64).map(|()| String::new());
+    }
+    let checksums = fetch_release_text(agent, release, CHECKSUMS_ASSET_NAME, config)?;
+    let signature = fetch_release_text(agent, release, CHECKSUMS_SIGNATURE_ASSET_NAME, config)?;
+    verify_checksums_signature(checksums.as_bytes(), &signature, public_key_b64)?;
+    Ok(checksums)
 }

 /// Event-Typen für den asynchronen Worker.
@@ -368,6 +424,17 @@ pub enum UpdaterStatus {
    Error(String),
 }

+/// Lehnt jede URL ohne HTTPS ab, sofern unsicheres HTTP nicht ausdrücklich erlaubt ist.
+fn ensure_secure_scheme(url: &url::Url, allow_insecure_http: bool) -> Result<(), String> {
+    match url.scheme() {
+        "https" => Ok(()),
+        "http" if allow_insecure_http => Ok(()),
+        scheme => Err(format!(
+            "Unsicheres Protokoll '{scheme}' für '{url}' abgewiesen. Es wird zwingend HTTPS verlangt."
+        )),
+    }
+}
+
 /// Erstellt einen ureq Agent mit sauberen Timeouts.
 fn create_http_agent() -> ureq::Agent {
    ureq::AgentBuilder::new()
@@ -384,12 +451,15 @@ fn http_get_with_auth_guard(
    initial_url_str: &str,
    token: Option<&str>,
    max_redirects: usize,
+    allow_insecure_http: bool,
 ) -> Result<ureq::Response, String> {
    let mut current_url = url::Url::parse(initial_url_str)
        .map_err(|e| format!("Ungültige URL '{initial_url_str}': {e}"))?;
    let initial_origin = current_url.origin().ascii_serialization();

    for _ in 0..=max_redirects {
+        // Jede Anfrage prüfen – auch Download-Links aus der API und Weiterleitungsziele
+        ensure_secure_scheme(&current_url, allow_insecure_http)?;
        let mut req = agent.get(current_url.as_str());

        // Token NUR anhängen, wenn Origin (Scheme, Host, Port) identisch ist
@@ -500,7 +570,13 @@ impl UpdaterController {
            );

            let agent = create_http_agent();
-            match http_get_with_auth_guard(&agent, &api_url, config.auth_token.as_deref(), 5) {
+            match http_get_with_auth_guard(
+                &agent,
+                &api_url,
+                config.auth_token.as_deref(),
+                5,
+                config.allow_insecure_http,
+            ) {
                Ok(resp) => match resp.into_json::<GiteaRelease>() {
                    Ok(release) => {
                        if release.prerelease && !config.include_prereleases {
@@ -563,12 +639,37 @@ impl UpdaterController {
            let target_file = cache_dir.join(&safe_asset_name);
            let agent = create_http_agent();

-            // 1. Download des Release-Assets mit Fortschritts-Streaming
+            // 1. Signierte Prüfsummen laden und verifizieren, BEVOR das Paket geladen wird
+            let checksums_content = match active_release.as_ref() {
+                Some(release) => match fetch_verified_checksums(
+                    &agent,
+                    release,
+                    &config,
+                    UPDATE_SIGNING_PUBLIC_KEY,
+                ) {
+                    Ok(text) => text,
+                    Err(e) => {
+                        let _ = tx.send(UpdaterEvent::DownloadError(format!(
+                            "{e} Download abgelehnt."
+                        )));
+                        return;
+                    }
+                },
+                None => {
+                    let _ = tx.send(UpdaterEvent::DownloadError(
+                        "Kein Release ausgewählt. Download abgelehnt.".to_string(),
+                    ));
+                    return;
+                }
+            };
+
+            // 2. Download des Release-Assets mit Fortschritts-Streaming
            let resp = match http_get_with_auth_guard(
                &agent,
                &asset.browser_download_url,
                config.auth_token.as_deref(),
                5,
+                config.allow_insecure_http,
            ) {
                Ok(r) => r,
                Err(e) => {
@@ -646,53 +747,13 @@ impl UpdaterController {

            drop(file);

-            // 2. Integritätsprüfung gegen SHA256SUMS.txt
-            let checksum_asset = active_release
-                .as_ref()
-                .and_then(|r| r.assets.iter().find(|a| a.name == "SHA256SUMS.txt"));
-
-            let checksums_content = match checksum_asset {
-                Some(ca) => {
-                    match http_get_with_auth_guard(
-                        &agent,
-                        &ca.browser_download_url,
-                        config.auth_token.as_deref(),
-                        5,
-                    ) {
-                        Ok(c_resp) => match c_resp.into_string() {
-                            Ok(text) => text,
-                            Err(e) => {
-                                let _ = std::fs::remove_file(&target_file);
-                                let _ = tx.send(UpdaterEvent::DownloadError(format!(
-                                    "Konnte SHA256SUMS.txt nicht dekodieren: {e}. Datei gelöscht."
-                                )));
-                                return;
-                            }
-                        },
-                        Err(e) => {
-                            let _ = std::fs::remove_file(&target_file);
-                            let _ = tx.send(UpdaterEvent::DownloadError(format!(
-                                "Konnte SHA256SUMS.txt nicht laden: {e}. Datei aus Sicherheitsgründen gelöscht."
-                            )));
-                            return;
-                        }
-                    }
-                }
-                None => {
-                    let _ = std::fs::remove_file(&target_file);
-                    let _ = tx.send(UpdaterEvent::DownloadError(
-                        "Release enthält keine SHA256SUMS.txt-Prüfsummen. Download abgelehnt und gelöscht.".to_string(),
-                    ));
-                    return;
-                }
-            };
-
+            // 3. Integritätsprüfung des Pakets gegen die signierte SHA256SUMS.txt
            if let Err(err) = verify_checksum(&target_file, &safe_asset_name, &checksums_content) {
                let _ = tx.send(UpdaterEvent::DownloadError(err));
                return;
            }

-            // 3. Wenn es ein AppImage ist, Executable-Bit auf 0755 setzen
+            // 4. Wenn es ein AppImage ist, Executable-Bit auf 0755 setzen
            if safe_asset_name.ends_with(".AppImage") {
                #[cfg(unix)]
                {
@@ -996,6 +1057,81 @@ dcdeb7ac87d9e6cb8022e5a71bc7f2c56d779b4fce4efdd5bae5be3b0214884a  ink-notes_0.1.
        assert!(allowed_insecure.validate_url().is_ok());
    }

+    /// Nur für Tests erzeugtes Minisign-Schlüsselpaar (der geheime Schlüssel wurde verworfen).
+    const TEST_PUBLIC_KEY: &str = "RWQr5S8CVgsjS4UA3uY0xqTDua4uRSSzKWpFfJKLCypjgP3NGt9Tmdbh";
+    const TEST_CHECKSUMS: &str = "abc123  ink-notes_9.9.9_amd64.deb\n";
+    const TEST_SIGNATURE: &str = "untrusted comment: signature from rsign secret key
+RUQr5S8CVgsjS5BYMUx1ICe1E356aP7wesQXw+oKF6Rd8WsvdF1dmCb1ffonXgJ2GhWE5iAWPXQaT8Y/Y4zLIpyS1PA8JCe8eAM=
+trusted comment: ink-notes test
+iw0NOedyAQg3emO36fHjyfn+AbnI7Idyl+NwFTDJX1YceLM1jSfjIfeIc0D49IQXyGTpM/QnkZJkRO/eI8ZKBQ==
+";
+
+    #[test]
+    fn test_checksums_signature_verification() {
+        // Gültige Signatur
+        assert!(verify_checksums_signature(
+            TEST_CHECKSUMS.as_bytes(),
+            TEST_SIGNATURE,
+            TEST_PUBLIC_KEY
+        )
+        .is_ok());
+
+        // Manipulierte Prüfsummen (z. B. ausgetauschter Hash)
+        let tampered = TEST_CHECKSUMS.replace("abc123", "abc124");
+        assert!(
+            verify_checksums_signature(tampered.as_bytes(), TEST_SIGNATURE, TEST_PUBLIC_KEY)
+                .is_err()
+        );
+
+        // Fremder Schlüssel
+        let other_key = "RWQf6LRCGA9i53mlYecO4IzT51TGPpvWucNSCh1CBM0QTaLn73Y7GFO3";
+        assert!(
+            verify_checksums_signature(TEST_CHECKSUMS.as_bytes(), TEST_SIGNATURE, other_key)
+                .is_err()
+        );
+
+        // Kein Schlüssel hinterlegt -> strikt ablehnen
+        let err =
+            verify_checksums_signature(TEST_CHECKSUMS.as_bytes(), TEST_SIGNATURE, "").unwrap_err();
+        assert!(err.contains("kein Signaturschlüssel"), "{err}");
+
+        // Fehlende / kaputte Signatur
+        assert!(
+            verify_checksums_signature(TEST_CHECKSUMS.as_bytes(), "", TEST_PUBLIC_KEY).is_err()
+        );
+
+        // Altes (nicht prehashed) Signaturformat wird nicht akzeptiert
+        let legacy_sig = "untrusted comment: signature from minisign secret key
+RWQf6LRCGA9i59SLOFxz6NxvASXDJeRtuZykwQepbDEGt87ig1BNpWaVWuNrm73YiIiJbq71Wi+dP9eKL8OC351vwIasSSbXxwA=
+trusted comment: timestamp:1555779966\tfile:test
+QtKMXWyYcwdpZAlPF7tE2ENJkRd1ujvKjlj1m9RtHTBnZPa5WKU5uWRs5GoP5M/VqE81QFuMKI5k/SfNQUaOAA==";
+        assert!(verify_checksums_signature(b"test", legacy_sig, other_key).is_err());
+    }
+
+    #[test]
+    fn test_https_enforced_for_every_request() {
+        let https = url::Url::parse("https://gitea.pansi.eu/a.deb").unwrap();
+        let http = url::Url::parse("http://cdn.example.com/a.deb").unwrap();
+        let ftp = url::Url::parse("ftp://example.com/a.deb").unwrap();
+        assert!(ensure_secure_scheme(&https, false).is_ok());
+        assert!(ensure_secure_scheme(&http, false).is_err());
+        assert!(ensure_secure_scheme(&http, true).is_ok());
+        assert!(ensure_secure_scheme(&ftp, true).is_err());
+
+        // Ein http-Download-Link aus der Release-API wird abgewiesen, bevor eine
+        // Verbindung aufgebaut wird
+        let agent = create_http_agent();
+        let err = http_get_with_auth_guard(
+            &agent,
+            "http://127.0.0.1:9/ink-notes.AppImage",
+            Some("geheim"),
+            5,
+            false,
+        )
+        .unwrap_err();
+        assert!(err.contains("HTTPS"), "{err}");
+    }
+
    #[test]
    fn test_appimage_atomic_self_update() {
        let temp_dir = tempfile::tempdir().unwrap();
Author	SHA1	Message	Date
haraldandClaude Opus 5.5	f76fad92be	chore(release): bump version to 0.3.3 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 9m10s Details Behebt Datenverlust nach Neustart auf einer späteren Seite (v0.2.3 – v0.3.2); Seitenauswahl mit Vorschaubildern. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 07:32:58 +02:00
haraldandClaude Opus 5.5	2c60a03460	feat(ui): Vorschaubilder in der Seitenauswahl - Kacheln zeigen eine verkleinerte A4-Vorschau jeder Seite (Striche als Linien, Textmarker halbtransparent, volle Seiten auf ~1500 Punkte ausgedünnt), Seitenzahl darunter, aktuelle Seite blau umrandet - Noch nicht geladene Seiten werden bei offener Seitenauswahl nachgeladen (UiAction::LoadAllPages) - Kachelgröße über PAGE_TILE (vorher feste Werte) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 07:03:08 +02:00
haraldandClaude Opus 5.5	b6580f197d	fix(storage): Inhalt der zuletzt geöffneten Seite nach Neustart nicht überschreiben Beim Start wurde nur die erste Seite geladen. War zuletzt eine spätere Seite offen, war sie nach dem Neustart ein leerer, ungeladener Platzhalter: Das Blatt erschien leer, und Zeichnen/Radieren/Hintergrund wechseln speicherte den Platzhalter und überschrieb den bisherigen Inhalt der Seite. - load_notebook lädt zusätzlich die aktuelle Seite - Autosave schreibt nie ungeladene Platzhalter (Schutz ging beim Merge des Storage-Branches verloren) - Regressionstests für beide Fälle Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 07:03:08 +02:00
haraldandClaude Opus 5.5	22e35f2e77	chore(release): bump version to 0.3.2 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 9m33s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 06:40:44 +02:00
haraldandClaude Opus 5.5	a77e6cde90	feat(ui): einheitliche, deckende Dialoge und fingertaugliche Popover - Dialoge (Notizbücher, Updates, Warnfenster) mit gemeinsamem deckendem Rahmen, ohne doppelte Titelleiste, zentriert neben der Werkzeugleiste; Schließen-Knopf 36 px, größere Knöpfe, Eingabefelder und Schieberegler - Seitenauswahl als Popover neben dem Seitenknopf mit Kachelraster (56 × 48 px) und „Neue Seite anhängen“ - Immer nur ein Dialog oder Popover gleichzeitig offen (close_overlays); Seitenauswahl schließt bei Tippen daneben - Stift-/Marker-Popover: Farbtupfer 30 px, Stärke-Vorschau 40 px hoch, breiterer Schieberegler, deckender Rahmen - Auswahl-Überlagerung und Griff-Trefferprüfung rechnen mit der Display-Skalierung (lag bei Skalierung ≠ 1 neben den Strichen); Trefferradius der Griffe 18 Punkte für Finger Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 23:51:48 +02:00
haraldandClaude Opus 5.5	40eb9a666f	chore(release): bump version to 0.3.1 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 10m58s Details Behebt: In v0.3.0 ließ sich auf dem Blatt nicht zeichnen. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 23:16:54 +02:00
haraldandClaude Opus 5.5	85d1ba1647	fix(ui): Zeichnen auf dem Blatt wieder möglich; Farben und Zeichen korrigiert Regression aus v0.3.0: Die UI-Trefferprüfung (egui layer_id_at) wertete eine bildschirmfüllende egui-Ebene der Ordnung Background als UI. Dadurch galt jeder Punkt auf dem Blatt als Oberfläche, und Maus, Stift und Touch zeichneten nicht. Background-Ebenen zählen jetzt nicht mehr als UI; die Prüfung liegt in ui.rs und ist durch einen Test abgedeckt (Blattpunkte, Leiste, Skalierung 1 und 2). Außerdem: - 25 ungültige vormultiplizierte Farben (RGB > Alpha) auf unmultipliziert umgestellt: Knöpfe in Dialogen waren weiße Kästen mit unlesbarer Schrift, die Auswahlfüllung war deckend statt durchscheinend - Zeichen ohne Glyphe in den egui-Schriften ersetzt (✓ ✕ ● ↑ ↓, Variantenzeichen U+FE0F hinter ⚠) - Tests finden künftig ungültige Farben und nicht darstellbare Zeichen in ui.rs, selection.rs und main.rs Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 23:12:56 +02:00
haraldandClaude Opus 5.5	b03faedd27	chore(release): bump version to 0.3.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 11m42s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 22:26:27 +02:00
haraldandClaude Opus 5.5	f17e50ec32	feat(ui): senkrechte Werkzeugleiste und Stift-/Touch-Bedienung der UI Werkzeugleiste - Schmale senkrechte Leiste statt ~30 Elemente in einer Zeile; seitlich oben angedockt (links, im ☰-Menü auf rechts umschaltbar, gespeichert in ~/.config/ink-notes/ui.json) - Symbol-Knöpfe 40 px, auf niedrigen Fenstern schrittweise bis 28 px; Größe richtet sich nach dem höchsten Fall, damit Knöpfe beim Werkzeugwechsel nicht springen (fester Platz für die Farbpalette) - Selten genutztes (PDF, Hintergrund, Zoom, Finger-Zeichnen, Leistenseite, Updates, Speicherstatus) im ☰-Menü; Popover öffnen zur Blattseite hin - Blatt wird im freien Bereich neben der Leiste zentriert - Symbole ohne Glyphe in den egui-Schriften (🖍 ⌫ ⬚ ◄ ► ● ✕ ▾) ersetzt bzw. selbst gezeichnet; Hover-Farbe korrigiert (falsch vormultipliziert) Eingabe - UI-Trefferprüfung in logischen Punkten (vorher physische Pixel gegen egui-Koordinaten: bei Skalierung ≠ 1 trafen Stift und Touch die Leiste nicht) und über egui::Context::layer_id_at für alle egui-Bereiche - Stift-Ereignisse über egui_input_mut() statt ctx.input_mut() (wurden vom nächsten Frame verworfen); Stiftbewegungen für Hover/Ziehen weitergereicht, Stift bleibt vom Aufsetzen bis Abheben bei der UI - Berührungen, die auf der UI beginnen, bleiben bis zum Abheben bei egui - egui-Neuzeichenwünsche (repaint_delay) werden beachtet Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 22:16:51 +02:00
haraldandClaude Opus 5.5	5cd45831e2	chore(release): bump version to 0.2.3 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 10m30s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 21:04:54 +02:00
haraldandClaude Opus 5.5	71f6a70829	fix(ci): Release-Signatur mit rsign2 statt minisign-CLI Der Signaturschlüssel wurde mit `rsign generate -W` erzeugt und ist mit leerem Passwort verschlüsselt; das minisign-CLI aus Ubuntu (0.11) verlangt dafür ein Terminal und brach in der CI mit "Error while loading the secret key file" ab. - Workflow installiert rsign2 0.6.7 (ohne -D warnings) statt minisign - build-release.sh signiert und verifiziert mit rsign; da rsign bei falscher Key-ID mit Exit-Code 0 endet, wird zusätzlich die Erfolgsmeldung geprüft - README: Signierwerkzeug und Fallstrick dokumentiert Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 21:04:54 +02:00
haraldandClaude Opus 5.5	b751b71223	chore(release): bump version to 0.2.2 Build & Publish Release / Build Packages & Publish to Gitea (push) Failing after 9m55s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 20:44:51 +02:00
haraldandClaude Opus 5.5	afb057692d	fix(ci): rustfmt und clippy in der Release-Pipeline installieren setup-rust-toolchain installiert mit --profile minimal; ohne explizite components fehlen rustfmt und clippy, wodurch die Quality Gates bei jedem Release-Lauf sofort abbrachen (cargo fmt --check nach 2 Sekunden). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 20:42:58 +02:00
haraldandClaude Opus 5.5	eeae143dc6	chore(release): bump version to 0.2.1 Build & Publish Release / Build Packages & Publish to Gitea (push) Failing after 1m55s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 20:35:10 +02:00
haraldandClaude Opus 5.5	992c3daad7	fix(ci): Formatierung, Root-fester I/O-Test und robuste Schlüsselsuche - updater.rs: rustfmt-konforme Formatierung des öffentlichen Schlüssels (cargo fmt --check ließ die Release-Pipeline scheitern) - storage.rs: test_io_error_* simuliert den I/O-Fehler über ein Verzeichnis statt chmod 000, damit er auch als root (CI-Runner) greift - build-release.sh: findet den öffentlichen Schlüssel auch, wenn rustfmt ihn in die Folgezeile umbricht Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 20:30:52 +02:00
haraldandClaude Opus 5.5	9684238a53	chore(release): bump version to 0.2.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Failing after 2m28s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 20:20:29 +02:00
haraldandClaude Opus 5.5	e8674e730f	feat(updater): Minisign-Schlüssel für Release-Signaturen hinterlegen Öffentlicher Schlüssel (Key-ID 3CFE290C190DA9D9). Der geheime Schlüssel wird in der CI als Secret MINISIGN_SECRET_KEY erwartet. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 20:10:57 +02:00
haraldandClaude Opus 5.5	7e99d59042	Merge fix/storage-datensicherheit in main Konfliktlösung: Speicher-Architektur des Branches (Formatversionierung, Papierkorb, Backups, Instance-Lock, robuster Autosave) übernommen und die dort fehlenden Korrekturen aus main darauf übertragen: - Autosave gleicht das Manifest bei jeder Änderung mit dem Notizbuch ab (mark_dirty); per Taste N/Bild-ab angelegte Seiten gingen sonst nach einem Neustart verloren - Start öffnet keine beschädigten Notizbücher automatisch und verwendet den Ordner eines nicht ladbaren Notizbuchs nicht wieder - PDF-Export lädt nicht geöffnete Seiten nach (load_all_pages), verweigert unvollständige Exporte und meldet das echte Ergebnis an die UI - Cargo.toml: minisign-verify und fs2 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 20:07:22 +02:00
haraldandClaude Opus 5.5	7ed971d2a2	feat(updater): Pflicht-Signaturprüfung der Releases mit Minisign - SHA256SUMS.txt muss mit dem eingebauten Minisign-Schlüssel (UPDATE_SIGNING_PUBLIC_KEY) signiert sein; fehlende oder ungültige Signaturen und Versionen ohne Schlüssel lehnen Updates ab - Prüfsummen und Signatur werden vor dem Paket geladen und geprüft - build-release.sh signiert mit MINISIGN_SECRET_KEY und prüft, dass der Schlüssel zum eingebauten öffentlichen Schlüssel passt; in der CI ist die Signatur Pflicht - publish-gitea-release.sh lädt SHA256SUMS.txt.minisig hoch - README: Einrichtung des Schlüsselpaars dokumentiert Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 19:49:25 +02:00
haraldandClaude Opus 5.5	5ce2c250bb	fix(updater): HTTPS für alle Anfragen erzwingen Bisher wurde nur die Server-URL geprüft. Download-Links aus der Release-API und Weiterleitungsziele durften auch http:// sein, womit Paket und SHA256SUMS.txt unverschlüsselt geladen werden konnten. Jetzt wird jede Anfrage einzeln geprüft (allow_insecure_http bleibt als Ausnahme). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 19:45:16 +02:00
haraldandClaude Opus 5.5	d61e1819ed	fix(storage): Datenverlust bei Ladefehlern, neuen Seiten und Löschen verhindern - Beschädigte Seiten werden als page_<id>.json.corrupt-<zeit> gesichert statt leer überschrieben; bei I/O-Fehlern wird die Ersatzseite als load_failed markiert und nie gespeichert - Autosave gleicht das Manifest (page_ids, Zähler) mit dem Notizbuch ab, damit neu angelegte Seiten nach einem Neustart nicht verloren gehen - Start: nicht ladbares Notizbuch bleibt unverändert, stattdessen wird ein neues angelegt - Aktuelles Notizbuch löschen: ausstehende Schreibvorgänge vorher abarbeiten, damit der Ordner nicht wieder angelegt wird - PDF-Export lädt nicht geöffnete Seiten nach und verweigert unvollständige Exporte; Ergebnis wird per Kanal an die UI gemeldet - Strg+S speichert alle geladenen Seiten und meldet Schreibfehler; flush() liefert Fehler zurück statt immer "Gespeichert" Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-06 19:43:16 +02:00