chore(release): bump version to 0.7.0

Teilstrich-Radierer, Seiten-Export als PNG/SVG, Auswahl als Bild, Seitentitel.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.gitea/workflows/release.yaml

@@ -9,15 +9,25 @@ on:
 jobs:
   release:
     name: Build Packages & Publish to Gitea
+    # Hinweis zum Gitea act_runner:
+    # Standardmäßig 'ubuntu-latest'. Falls Ihr Runner unter einem anderen Label registriert ist
+    # (z. B. 'linux', 'ubuntu-24.04' oder 'host'), passen Sie dieses Label an.
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v4.2.2
 
       - name: Install System Packaging Tools
         run: |
-          sudo apt-get update
-          sudo apt-get install -y --no-install-recommends \
+          export DEBIAN_FRONTEND=noninteractive
+          SUDO=""
+          if [ "$(id -u)" -ne 0 ]; then
+            if command -v sudo >/dev/null 2>&1; then
+              SUDO="sudo"
+            fi
+          fi
+          $SUDO apt-get update -y
+          $SUDO apt-get install -y --no-install-recommends \
             build-essential \
             pkg-config \
             libx11-dev \
@@ -31,20 +41,37 @@ jobs:
             python3
 
       - name: Setup Rust Toolchain
-        uses: actions-rust-lang/setup-rust-toolchain@v1
+        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: Build Release Artifacts (.deb, .AppImage, SHA256SUMS.txt)
+      - 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 + .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: |
-          ./scripts/publish-gitea-release.sh "${{ secrets.GITEA_TOKEN || secrets.GITHUB_TOKEN }}"
+          ./scripts/publish-gitea-release.sh
         env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN || secrets.GITHUB_TOKEN }}
           GITEA_SERVER: ${{ github.server_url }}
           REPO_OWNER: ${{ github.repository_owner }}
           REPO_NAME: ${{ github.event.repository.name }}

Cargo.toml

@@ -1,7 +1,12 @@
 [package]
 name = "ink-notes"
-version = "0.1.0"
+version = "0.7.0"
 edition = "2021"
+description = "Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux"
+repository = "https://gitea.pansi.eu/harald/ink-notes"
+license = "MIT"
+readme = "README.md"
+rust-version = "1.92"
 
 [dependencies]
 # Fenster- & Event-Handling (Wayland/X11, Stylus)
@@ -29,6 +34,19 @@ egui = "0.27"
 egui-wgpu = "0.27"
 egui-winit = { version = "0.27", default-features = false, features = ["links"] }
 webbrowser = "0.8"
+semver = "1.0"
+sha2 = "0.10"
+ureq = { version = "2.10", default-features = false, features = ["tls", "gzip", "json"] }
+url = "2.5"
+octotablet = "0.1.0"
+
+# Bilder einfügen: Dekodieren (PNG/JPEG/GIF/WebP/BMP) und Systemzwischenablage
+image = { version = "0.25", default-features = false, features = ["png", "jpeg", "gif", "webp", "bmp"] }
+arboard = { version = "3", default-features = false, features = ["image-data"] }
+minisign-verify = "0.3.0"
+fs2 = "0.4"
+hayro = "0.8"
+hayro-svg = "0.8"
 
 [profile.dev]
 opt-level = 1 # Erhöht Rendering-Performance auch im Debug-Modus
@@ -37,6 +55,9 @@ opt-level = 1 # Erhöht Rendering-Performance auch im Debug-Modus
 lto = true
 codegen-units = 1
 opt-level = 3
+strip = true
 
 [dev-dependencies]
 tempfile = "3.27.0"
+# Prüft den WGSL-Shader in den Tests (dieselbe Version wie in wgpu 0.19)
+naga = { version = "0.19", features = ["wgsl-in"] }

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Harald Pansi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -10,9 +10,10 @@ Eine latenzoptimierte, hardwarebeschleunigte Inking- und Notizbuch-Anwendung fü
 
 ### ⚡ Latenzoptimierte Inking-Pipeline
 - **Hardware-Rendering:** Direct-to-Screen-Rendering mit `wgpu` (Vulkan / X11 / Wayland) unter Nutzung von `PresentMode::Mailbox` für minimale Eingabeverzögerung.
-- **1€-Filter (One-Euro-Filter):** Dynamischer Tiefpassfilter zur Glättung von Zittern bei langsamen Bewegungen ohne spürbare Latenz bei schnellen Schwüngen.
+- **Zwei-Stufen-Modell:**
+  1. *Live-Phase:* Eingehende Stylus-Samples werden in Echtzeit durch einen 1€-Filter (One-Euro-Filter) entprellt und inkrementell als GPU-Meshes dargestellt.
+  2. *Commit-Phase (Post-Stroke Finalisierung):* Akausale Ecken-Erkennung (Corner Preservation bei Knicken > 65°), gewichtetes 3-Punkt-Druckfenster, Ramer-Douglas-Peucker (RDP) Dezimierung und saubere runde Endkappen.
 - **Centripetal Catmull-Rom Splines:** Weiche C1-stetige Kurveninterpolation ohne Überschwinger oder Schleifen.
-- **Drucksensitive Dreiecksstreifen-Tessellierung:** Rechnerische Generierung von Triangle-Meshes mit winkelhalbierenden Normalenvektoren entlang des Pfads.
 - **Werkzeuge:**
   - **Stift (Pen):** Feine, variable Strichstärken (0.3 mm bis 1.2 mm) mit Notiz-Farben (Schwarz, Blau, Rot, Grün, Grau).
   - **Textmarker (Highlighter):** Breite, halbtransparente Striche (4.0 mm bis 8.0 mm) mit Multiplikations-Blending.
@@ -29,7 +30,7 @@ Eine latenzoptimierte, hardwarebeschleunigte Inking- und Notizbuch-Anwendung fü
   - **Geraden (Line):** Sehnen- zu Pfadlängenverhältnis > 0.92.
   - **Rechtecke (Rectangle):** 4 orthogonale Ecken via Douglas-Peucker-Polygonzug (RDP).
   - **Kreise & Ellipsen (Circle/Ellipse):** Geschlossene Pfade mit minimaler Varianz via Least-Squares Circle Fit.
-  - **Koordinatensysteme (Axes):** Zwei orthogonale Achsen (80°–100° gesnappt auf exakt 90°) mit optionalen Richtungspfeilen.
+  - **Koordinatensysteme (Axes):** Zwei orthogonale Achsen (80°–100° gesnappt auf exakt 90°) mit Richtungspfeilen.
   - **Dreiecke, Rhomben / Rauten & Oktaeder:** Regelmäßige Polygone mit Eckpunkt-Analyse.
 - **Interaktionsmodelle:**
   - **Draw-and-Hold:** Verweilt der Stift am Ende eines Strichs für > 400 ms regungslos (< 3 px), snappt die Skizze sofort automatisch in eine perfekte Vektorform ein.
@@ -46,93 +47,158 @@ Eine latenzoptimierte, hardwarebeschleunigte Inking- und Notizbuch-Anwendung fü
 
 ### 📚 Multi-Dokumenten- & Notizbuch-Verwaltung
 - **Dateisystem-Architektur:** Jedes Dokument wird in einem separaten Verzeichnis unter `~/.local/share/ink-notes/notebooks/<id>/` mit `manifest.json` und Einzelseiten (`page_<id>.json`) gespeichert.
-- **Dokumenten-Manager:** Dunkles Glassmorphism-Modal direkt in der Toolbar:
-  - Neues Notizbuch anlegen.
-  - Zwischen Notizbüchern mit einem Klick wechseln.
-  - Dokumente direkt umbenennen (`✏`).
-  - Dokumente löschen (`🗑`).
+- **Dokumenten-Manager:** Toolbar-Modal zum Anlegen, Wechseln, Umbenennen und Löschen von Notizbüchern.
 - **Verlustfreier Wechsel:** Beim Dokumentenwechsel sichert ein synchroner Disk-Flush alle anstehenden Änderungen garantiert ab.
 
 ### 📄 Seiten & Hintergründe
 - **Virtuelles DIN-A4-Raster:** 2100 × 2970 Koordinateneinheiten (10 Einheiten = 1 mm).
-- **Hintergrundmuster:**
-  - Blanko
-  - Kariert (5 mm Raster)
-  - Liniert (7.5 mm Zeilenabstand)
-  - Punktraster (5 mm Dot-Grid)
+- **Hintergrundmuster:** Blanko, Kariert (5 mm), Liniert (7.5 mm), Punktraster (5 mm).
 - **Seitenverwaltung:** Vor- und Zurückblättern, neue Seiten anfügen, Seitensprung-Menü.
 
 ### 💾 Autosave & Persistenz
-- **Asynchroner Autosave-Controller:** Sichert Änderungen im Hintergrund-Thread nach 1.5 s Ruhezeit (Debounce), ohne das Zeichnen zu blockieren.
+- **Asynchroner Autosave-Controller:** Sichert Änderungen im Hintergrund nach 1.5 s Ruhezeit (Debounce), ohne das Zeichnen zu blockieren.
 - **Atomares Schreiben:** Temp-Dateien mit atomarem Rename (`manifest.json.tmp` -> `manifest.json`) schützen vor Datenkorruption bei Abstürzen.
-- **Sicherer Shutdown:** `ESC` oder Schließen des Fensters führt vor Programmende einen vollständigen synchronen Flush aus.
+- **Dediziertes Speichern (`Strg + S`):** Sofortiger, synchroner Disk-Flush mit visueller Toast-Rückmeldung.
+- **Sicherer Shutdown:** `Strg + Q` oder Schließen des Fensters führt vor Programmende einen vollständigen synchronen Flush aus.
 
 ### 🖨️ Vektor-PDF-Export
-- Exportiert das gesamte Dokument via `printpdf` nach `./export.pdf`.
-- Striche und geometrische Formen werden als skalierbare Vektoren ausgegeben.
+- Exportiert das Dokument via `printpdf` nach `~/Documents/<Titel>.pdf` (mit automatischer Kollisionsvermeidung `_1`, `_2`).
+- Striche und geometrische Formen werden als skalierbare Vektoren ausgegeben. Kürzel: `Strg + E`.
 
 ---
 
-### 🚀 Release, Packaging & In-App Auto-Update (Zorin OS 18 / Ubuntu)
-- **Natives .deb-Paket**: Optimiert für Zorin OS 18 (Ubuntu 24.04 LTS Noble-Basis) mit vollständiger XDG Desktop-Integration (`.desktop`, Hicolor-Icons SVG & 256x256 PNG, AppStream Metainfo).
-- **Portables .AppImage**: Eigenständiges, distributionsunabhängiges Bundle (x86_64) mit integrierten Laufzeitabhängigkeiten.
-- **In-App Gitea Updater (`src/updater.rs`)**:
-  - Fragt im Hintergrund die Gitea Releases API (`https://gitea.pansi.eu/api/v1/repos/harald/ink-notes/releases/latest`) ab.
-  - Zeigt bei neuen Versionen ein Update-Badge in der Toolbar an.
-  - Release-Modal mit Versionsvergleich, Changelog und 1-Click-Download / In-Place-Aktualisierung.
-- **Gitea Actions CI/CD (`.gitea/workflows/release.yaml`)**: Automatisches Paketieren und Veröffentlichen auf Gitea bei Git-Tags (`v*`).
+## 📦 Release, Packaging & Updater
 
----
-
-## 📦 Paketierung & Installation (Zorin OS 18)
+- **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, Minisign-Signaturprüfung, SHA-256-Prüfung und atomarer In-Place Austausch.
 
 ### 1. Release-Pakete bauen
 
 ```bash
-# Baut sowohl .deb als auch .AppImage und berechnet SHA256SUMS.txt in target/
+# Baut .deb, .AppImage und berechnet SHA256SUMS.txt in target/
 ./scripts/build-release.sh
 ```
 
 Ergebnis in `target/`:
-- `ink-notes_0.1.0_amd64.deb` (~4.2 MB)
-- `ink-notes_0.1.0_x86_64.AppImage` (~5.6 MB)
+- `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)
 
-### 2. Installation auf Zorin OS 18
+### 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
 
 ```bash
 # Natives Debian-Paket installieren
 sudo dpkg -i target/ink-notes_0.1.0_amd64.deb
 
-# Oder portables AppImage direkt starten
+# Oder portables AppImage starten
 chmod +x target/ink-notes_0.1.0_x86_64.AppImage
 ./target/ink-notes_0.1.0_x86_64.AppImage
 ```
 
-Nach der `.deb`-Installation ist `ink-notes` nahtlos im Zorin OS Anwendungsmenü unter *Büro* und *Grafik* integriert.
+#### Hinweise zu AppImage, glibc & FUSE:
+- **glibc-Mindestversion:** `ink-notes` benötigt `glibc >= 2.39` (Standard unter Ubuntu 24.04 LTS und Zorin OS 18).
+- **Host-Grafikstack:** Das AppImage bündelt die Anwendungslogik, nutzt für maximale Performance und Hardwarebeschleunigung jedoch den Treiber- und Grafikstack des Host-Systems (Vulkan ICD-Treiber, Wayland bzw. X11).
+- **FUSE 2 / FUSE 3 Kompatibilität:** Ubuntu 24.04-basierte Distributionen nutzen standardmäßig FUSE 3 (`fuse3`). Sollte das AppImage beim Start einen Fehler bezüglich `libfuse.so.2` ausgeben, kann entweder das Kompatibilitätspaket installiert werden:
+  ```bash
+  sudo apt install libfuse2t64
+  ```
+  oder das AppImage direkt ohne FUSE entpackt und ausgeführt werden:
+  ```bash
+  ./ink-notes_0.1.0_x86_64.AppImage --appimage-extract-and-run
+  ```
 
 ### 3. Release auf Gitea veröffentlichen
 
+Das Skript arbeitet vollkommen idempotent und aktualisiert bei wiederholter Ausführung Release-Notizen und Assets:
+
 ```bash
-# Veröffentlicht die Artefakte auf https://gitea.pansi.eu/harald/ink-notes
-./scripts/publish-gitea-release.sh <DEIN_GITEA_TOKEN>
+export GITEA_TOKEN="<DEIN_GITEA_TOKEN>"
+./scripts/publish-gitea-release.sh
 ```
 
 ---
 
+## 🛡️ Updater-Sicherheit
+
+Der In-App-Updater (`src/updater.rs`) folgt strengen Sicherheitsrichtlinien:
+
+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.
+3. **Redirect-Schutz & 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`).
+   - Asset-Namen werden sanitisiert: Pfadtrenner (`/`, `\`), Pfadüberquerungen (`..`), Steuerzeichen und leere Dateinamen werden strikt abgewiesen.
+5. **Atomarer AppImage-Tausch:**
+   - Kein direktes Überschreiben laufender Programmdateien per `fs::copy` (verhindert den Linux-Kernel-Fehler *"Text file busy"*).
+   - Die neue Datei wird temporär im selben Verzeichnis angelegt (`<name>.new.<pid>`), mit Ausführungsrechten (`0755`) versehen, das bestehende AppImage als `<name>.bak` gesichert (dessen Fehler nicht ignoriert werden) und anschließend per atomarem `fs::rename` ausgetauscht.
+
+---
+
+## ⚙️ CI-Runner einrichten (Gitea Actions / act_runner)
+
+Der Veröffentlichungs-Workflow liegt unter [`.gitea/workflows/release.yaml`](.gitea/workflows/release.yaml).
+
+### Runner-Label konfigurieren
+Der Workflow nutzt standardmäßig das Runner-Label:
+```yaml
+runs-on: ubuntu-latest
+```
+
+In der Konfigurationsdatei Ihres Gitea `act_runner` (`config.yaml`) muss dieses Label auf ein passendes Container-Image oder den Host gemappt sein:
+```yaml
+runner:
+  labels:
+    - "ubuntu-latest:docker://catthehacker/ubuntu:act-latest"
+    # oder für native Host-Ausführung:
+    # - "ubuntu-latest:host"
+```
+
+### Diagnose & Fehlerbehebung
+Bleibt ein Release-Job auf **"Waiting to run"** hängen:
+1. **Runner online?** Prüfen Sie in Gitea unter *Einstellungen -> Aktionen -> Runner*, ob der `act_runner` aktiv und mit einem grünen Punkt als *Online* markiert ist.
+2. **Label-Übereinstimmung:** Stimmen die im Runner registrierten Labels exakt mit dem `runs-on`-Feld in `.gitea/workflows/release.yaml` überein?
+3. **Rechte:** Der Workflow prüft `if [ "$(id -u)" -ne 0 ]` und setzt `sudo` nur ein, wenn der Runner nicht als `root` läuft. Das verhindert Fehler sowohl in unprivilegierten Host-Umgebungen als auch in Root-Containern.
+
+---
+
 ## 🚀 Schnellstart (Entwicklung)
 
 ### Voraussetzungen
 - **Rust & Cargo:** Version 1.75 oder neuer (`rustup update stable`)
 - **System-Bibliotheken (Linux):**
   - Vulkan-Treiber (z. B. `mesa-vulkan-drivers` oder proprietäre Treiber)
-  - X11 / XWayland Bibliotheken (`libx11-dev`, `libxcursor-dev`, `libxrandr-dev`, `libxi-dev`, `libxkbcommon-dev`)
+  - X11 / Wayland Bibliotheken (`libx11-dev`, `libxcursor-dev`, `libxrandr-dev`, `libxi-dev`, `libxkbcommon-dev`)
 
 ### Bauen & Ausführen
 
 ```bash
 # Repository klonen
-git clone gitea@farmersdog.pansi.eu:harald/ink-notes.git
+git clone https://gitea.pansi.eu/harald/ink-notes.git
 cd ink-notes
 
 # Kompilieren und starten via Starter-Skript
@@ -164,8 +230,10 @@ cargo run --release
 | **Nächste Seite** | `Bild ab (PageDown)` oder `N` |
 | **Vorherige Seite** | `Bild auf (PageUp)` |
 | **Erste / Letzte Seite** | `Pos 1 (Home)` / `Ende (End)` |
-| **PDF-Export** | `Strg + E` oder `Strg + S` |
-| **Beenden (mit Disk-Flush)** | `Esc` oder `Q` |
+| **Jetzt speichern (Disk Flush)** | `Strg + S` |
+| **Vektor-PDF-Export** | `Strg + E` |
+| **Dialoge / Menüs schließen** | `Esc` |
+| **Beenden (mit Disk-Flush)** | `Strg + Q` (oder Fenster schließen) |
 
 ---
 
@@ -179,7 +247,7 @@ src/
 ├── viewport.rs     # Kamera-Pan, Zoom, 2D-Transformationsmatrizen
 ├── shader.wgsl     # WGSL Vertex- & Fragment-Shader für Inking-Meshes
 ├── filter.rs       # One-Euro-Filter gegen Eingabe-Jitter
-├── spline.rs       # Centripetal Catmull-Rom & Dreiecksstreifen-Tessellierung
+├── spline.rs       # Catmull-Rom, Corner Preservation & Dreiecksstreifen
 ├── geometry.rs     # RDP-Algorithmus, Least-Squares Circle Fit, Shape Recognition
 ├── selection.rs    # Lasso-Auswahl, Bounding-Box, Griffe, Rotation & Skalierung
 ├── background.rs   # Tessellierung für Kariert, Liniert, Punktraster
@@ -187,7 +255,7 @@ src/
 ├── history.rs      # Undo/Redo-Transaktionsstapel (Add, Erase, Transform)
 ├── storage.rs      # Atomares Laden/Speichern von Manifest & Seiten, Multi-Notebooks
 ├── autosave.rs     # Debounced Hintergrund-Autosave mit MPSC-Kanal
-├── updater.rs      # In-App Gitea Updater (SemVer, Release-API, Download, Self-Update)
+├── updater.rs      # In-App Gitea Updater (SemVer, HTTPS, SHA256-Integrität, Self-Update)
 ├── export.rs       # Skalierbarer Vektor-PDF-Export via printpdf
 └── ui.rs           # Floating Glassmorphism-Toolbar, Dokumenten- & Update-Manager (egui)
 ```
@@ -198,16 +266,16 @@ Ausführliche Details zur Architektur und mathematischen Modellen findest du unt
 
 ## 🧪 Tests ausführen
 
-Die gesamte Inking-Pipeline, Geometrieerkennung, Speicherlogik und der Updater sind mit Unit-Tests abgesichert:
+Die gesamte Inking-Pipeline, Geometrieerkennung, Speicherlogik und der Updater sind mit umfassenden Unit-Tests abgesichert:
 
 ```bash
 cargo test
 ```
 
-Alle 61 Unit-Tests prüfen Berechnungen, Hit-Testing, Undo/Redo, Persistenz und Versionsvergleiche konsistent ab.
+Alle Unit-Tests prüfen Berechnungen, Hit-Testing, Undo/Redo, Persistenz, Updater-Sicherheit und Versionsvergleiche konsistent ab.
 
 ---
 
 ## 📄 Lizenz
 
-MIT License / Open Source Inking Project for Linux.
+Dieses Projekt ist unter der [MIT-Lizenz](LICENSE) lizenziert (Copyright © 2026 Harald Pansi).

docs/FILE_FORMAT.md

@@ -1,6 +1,6 @@
 # Dateiformat & Speicherstruktur von ink-notes
 
-Dieses Dokument beschreibt die Speicherstruktur und die JSON-Dateiformate, mit denen `ink-notes` Dokumente auf dem Dateisystem ablegt.
+Dieses Dokument beschreibt die Speicherstruktur, die JSON-Dateiformate und die Versionshistorie, mit denen `ink-notes` Dokumente auf dem Dateisystem ablegt.
 
 ---
 
@@ -13,7 +13,9 @@ Notizbücher werden standardmäßig unter dem XDG-Datenpfad gespeichert:
 └── notebooks/
     ├── <notebook_id_1>/
     │   ├── manifest.json
+    │   ├── manifest.json.v0.bak (optional, Migrations-Backup)
     │   ├── page_1.json
+    │   ├── page_1.json.corrupt-1775460000 (optional, Quarantäne bei Parsefehlern)
     │   ├── page_2.json
     │   └── ...
     └── <notebook_id_2>/
@@ -29,19 +31,20 @@ Das Manifest enthält Metadaten über das gesamte Dokument sowie die Reihenfolge
 
 ```json
 {
+  "format_version": 2,
   "id": "notebook-a1b2c3d4",
   "title": "Mathematik Vorlesung",
-  "version": 1,
   "pages": [
     {
       "id": 1,
-      "file_name": "page_1.json"
+      "background": "Grid5mm"
     },
     {
       "id": 2,
-      "file_name": "page_2.json"
+      "background": "DotGrid"
     }
   ],
+  "page_ids": [1, 2],
   "current_page_index": 0,
   "next_page_id": 3,
   "next_stroke_id": 42,
@@ -51,10 +54,11 @@ Das Manifest enthält Metadaten über das gesamte Dokument sowie die Reihenfolge
 ```
 
 ### Felder:
+- `format_version`: Format-Versionsnummer (aktuell `2`, bei unversionierten Legacy-Dateien implizit `0`).
 - `id`: Eindeutige ID des Notizbuchs (z. B. UUID oder `"default"`).
 - `title`: Vom Nutzer vergebener Anzeigename des Notizbuchs.
-- `version`: Format-Versionsnummer (aktuell `1`).
-- `pages`: Geordnete Liste von Seitenreferenzen.
+- `pages`: Geordnete Liste von Seitenmetadaten (`id`, optional `background`).
+- `page_ids`: Abwärtskompatible Liste der Seiten-IDs.
 - `current_page_index`: Index der zuletzt aktiven Seite für Session-Restore.
 - `next_page_id`: Inkrementierender ID-Zähler für neue Seiten.
 - `next_stroke_id`: Globaler ID-Zähler für neue Striche.
@@ -65,58 +69,21 @@ Das Manifest enthält Metadaten über das gesamte Dokument sowie die Reihenfolge
 ## 3. Seitendatei (`page_<id>.json`)
 
 Jede Seite wird in einer eigenen Datei gespeichert, um Lazy-Loading und schnelles inkrementelles Speichern zu ermöglichen.
+Die Speicherung erfolgt ab Version 2 als kompaktes JSON (`serde_json::to_vec`), wodurch gegenüber Pretty-Printed JSON über 50 % Speicherplatz eingespart wird.
 
 ```json
-{
-  "id": 1,
-  "background": "Grid5mm",
-  "strokes": [
-    {
-      "id": 1,
-      "color": [0.12, 0.12, 0.14, 1.0],
-      "width_mm": 0.5,
-      "samples": [
-        {
-          "x": 350.2,
-          "y": 420.5,
-          "pressure": 0.65,
-          "timestamp": 12.345
-        },
-        {
-          "x": 352.1,
-          "y": 425.8,
-          "pressure": 0.70,
-          "timestamp": 12.355
-        }
-      ],
-      "recognized_shape": null
-    },
-    {
-      "id": 2,
-      "color": [0.15, 0.35, 0.85, 1.0],
-      "width_mm": 0.8,
-      "samples": [],
-      "recognized_shape": {
-        "Rectangle": {
-          "top_left": { "x": 500.0, "y": 600.0 },
-          "width": 300.0,
-          "height": 200.0
-        }
-      }
-    }
-  ]
-}
+{"format_version":2,"id":1,"background":"Grid5mm","strokes":[{"id":1,"color":[0.12,0.12,0.14,1.0],"samples":[{"x":350.2,"y":420.5,"p":0.65,"t":12.345},{"x":352.1,"y":425.8,"p":0.70,"t":12.355}],"shape":null,"tool":"pen","width":5.0,"finalized":true},{"id":2,"color":[0.15,0.35,0.85,1.0],"samples":[],"shape":{"Rectangle":{"top_left":{"x":500.0,"y":600.0},"width":300.0,"height":200.0}},"tool":"shape","width":20.0,"finalized":true}]}
 ```
 
 ### Felder:
+- `format_version`: Format-Versionsnummer (`2`).
 - `id`: Eindeutige ID der Seite.
 - `background`: Papiermuster (`Blank`, `Grid5mm`, `Lined`, `DotGrid`).
 - `strokes`: Liste der auf der Seite gezeichneten Striche und Vektorformen.
   - `id`: Eindeutige ID des Strichs.
   - `color`: RGBA-Farbwerte im Bereich `[0.0, 1.0]`.
-  - `width_mm`: Basis-Strichbreite in Millimetern.
-  - `samples`: Rohabtastpunkte entlang des Pfads (`x`, `y` in DIN-A4-Einheiten, `pressure` in `[0.0, 1.0]`, `timestamp` in Sekunden).
-  - `recognized_shape`: Optionales Enum für geometrische Vektorformen:
+  - `samples`: Rohabtastpunkte entlang des Pfads (`x`, `y` in DIN-A4-Einheiten, `p` Druckwert in `[0.0, 1.0]`, `t` Zeitstempel in Sekunden).
+  - `shape`: Optionales Enum für geometrische Vektorformen:
     - `Line { start, end }`
     - `Rectangle { top_left, width, height }`
     - `Circle { center, radius }`
@@ -124,11 +91,47 @@ Jede Seite wird in einer eigenen Datei gespeichert, um Lazy-Loading und schnelle
     - `Triangle { p1, p2, p3 }`
     - `Rhombus { center, width, height }`
     - `Octahedron { center, radius }`
+  - `tool`: Zeichenwerkzeug (`"pen"`, `"highlighter"`, `"shape"`).
+  - `width`: Strichbreite in internen DIN-A4-Einheiten (10 Einheiten = 1 mm; z. B. `5.0` für 0.5 mm Stift, `60.0` für 6.0 mm Marker).
+  - `finalized`: Boolesches Flag für Striche, die das Zwei-Stufen-Inking (Eckenerkennung, Glättung, runde Endkappen) durchlaufen haben.
 
 ---
 
-## 4. Atomares Schreibverfahren
+## 4. Datensicherheit & Migration
 
-Um Datenverlust bei Stromausfall oder plötzlichem Prozessabbruch zu verhindern:
-1. Daten werden in `<ziel>.tmp` serialisiert und per `fsync` auf das Speichermedium geschrieben.
+### Atomares Schreiben & Verzeichnis-Sync
+1. Daten werden in `<ziel>.tmp.<pid>.<nanos>` serialisiert und per `fsync` auf das Speichermedium geschrieben (Dateirechte `0600` auf Unix).
 2. Mittels `std::fs::rename("<ziel>.tmp", "<ziel>")` wird die Zieldatei auf POSIX-Systemen atomar ersetzt.
+3. Nach dem Rename wird das übergeordnete Verzeichnis synchronisiert (`sync_all()`), um Persistenz bei Stromausfall zu garantieren. Verzeichnisse erhalten Berechtigung `0700`.
+
+### Quarantäne bei Parsefehlern
+Wird eine Seitendatei beim Laden als fehlerhaft erkannt (z. B. unvollständiges oder korruptes JSON), wird sie nicht stillschweigend gelöscht oder überschrieben, sondern nach `page_<id>.json.corrupt-<unix_ts>` verschoben. Die Ersatzseite wird als schreibgeschützt markiert.
+
+### Migrations-Backups & Rolling Backups
+Beim ersten Speichern einer Datei im Legacy-Format (Version 0) wird vor dem Überschreiben ein Backup `*.v0.bak` angelegt (z. B. `manifest.json.v0.bak`, `page_1.json.v0.bak`).
+Zusätzlich existiert ein Rolling-Backup `manifest.json.bak`, auf das bei beschädigtem Manifest automatisch zurückgegriffen wird.
+
+---
+
+## 5. Versionshistorie
+
+| Version | Status | Beschreibung |
+|---|---|---|
+| **0** | Legacy | Unversioniertes Format. `format_version` fehlt in JSON. Implizit als Version 0 interpretiert. |
+| **1** | Überholt | Einführung von `format_version: u32` in `manifest.json` und `page_<id>.json`. Seiten-Hintergrund im Manifest gecached (`pages: Vec<PageMeta>`). Strenges Versionsmatching (neuere Versionen werden abgelehnt). Automatische Migration mit `*.v0.bak`. |
+| **2** | **Aktuell** | Stroke-Treue: Ergänzung von `tool`, `width` und `finalized` in `StrokeData` für exakte Rekonstruktion aller Vertizes und Splines. Umstellung auf kompaktes JSON (`serde_json::to_vec`, ca. 54% Platzerparnis). |
+
+---
+
+## 6. Analyse & Bewertung: Binärformat (z. B. `postcard`)
+
+Eine Umstellung auf ein Binärformat wie `postcard` wurde evaluiert:
+- **Vorteile**:
+  - Weitere 20–30 % Reduktion der Dateigröße gegenüber kompaktem JSON.
+  - Minimal schnellere Serialisierung auf leistungsschwachen Systemen.
+- **Nachteile**:
+  - Verlust der Text-Transparenz (JSON lässt sich direkt inspizieren, mit `git`/Tools diffen und bei Korruption manuell reparieren).
+  - Snapshotting und JSON-Verarbeitung liegen im Benchmark bereits bei **0,02 ms (1k Samples)** bis **0,70 ms (50k Samples)** – also weit unter dem Zielwert von 1 ms.
+  - Kompaktes JSON spart bereits über 53 % Dateigröße ein.
+- **Entscheidung**:
+  Kompaktes JSON bietet aktuell das optimale Verhältnis aus Ausfallsicherheit, Benutzerfreundlichkeit, Performance und Portabilität. Ein Binärformat wie `postcard` bleibt als Option für spätere Riesen-Notizbücher (> 500 Seiten) denkbar, wird aktuell jedoch nicht eingeführt.

packaging/eu.pansi.ink-notes.desktop

@@ -0,0 +1,18 @@
+[Desktop Entry]
+Version=1.0
+Name=ink-notes
+GenericName=Notizbuch- & Inking-App
+Comment=Latenzoptimierte Vektor-Notizen mit Stylus, Stift & Geometrie-Erkennung
+Exec=ink-notes %F
+Icon=eu.pansi.ink-notes
+Terminal=false
+Type=Application
+Categories=Office;Graphics;Utility;
+Keywords=Note;Notiz;Pen;Stift;Ink;Inking;Stylus;Drawing;Zeichnen;PDF;Vector;
+StartupWMClass=ink-notes
+MimeType=application/x-inknotes;
+Actions=NewWindow;
+
+[Desktop Action NewWindow]
+Name=Neues Fenster
+Exec=ink-notes

packaging/eu.pansi.ink-notes.metainfo.xml

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<component type="desktop-application">
+  <id>eu.pansi.ink-notes</id>
+  <metadata_license>CC0-1.0</metadata_license>
+  <project_license>MIT</project_license>
+  <name>ink-notes</name>
+  <summary>Latenzoptimierte Vektor-Notizbuch- und Inking-App für Linux</summary>
+  <description>
+    <p>
+      ink-notes ist eine hardwarebeschleunigte, hochperformante Notizbuch- und Inking-Anwendung für Linux,
+      geschrieben in Rust mit wgpu. Sie bietet minimale Eingabelatenz mit Stylus, Touchpad oder Maus.
+    </p>
+    <p>Hauptmerkmale:</p>
+    <ul>
+      <li>Zwei-Stufen-Inking-Modell: Echtzeit-Glättung mit 1€-Filter und akausale Ecken-Erhaltung</li>
+      <li>Automatische Geometrie- und Formerkennung (Geraden, Rechtecke, Kreise, Koordinatensysteme, Polygone)</li>
+      <li>Stufenloser Viewport mit cursor-zentriertem Zoom (25% bis 500%) und Panning</li>
+      <li>Objektauswahl, Lasso, Skalieren, stufenloses Drehen und Multicolor-Umfärbung</li>
+      <li>Multi-Dokumenten- und Notizbuch-Verwaltung mit atomarem Autosave</li>
+      <li>Vektor-PDF-Export für Druck und Weitergabe</li>
+    </ul>
+  </description>
+  <launchable type="desktop-id">eu.pansi.ink-notes.desktop</launchable>
+  <provides>
+    <binary>ink-notes</binary>
+  </provides>
+  <categories>
+    <category>Office</category>
+    <category>Graphics</category>
+    <category>Utility</category>
+  </categories>
+  <developer id="eu.pansi">
+    <name>Harald</name>
+  </developer>
+  <url type="homepage">https://gitea.pansi.eu/harald/ink-notes</url>
+  <url type="bugtracker">https://gitea.pansi.eu/harald/ink-notes/issues</url>
+  <content_rating type="oars-1.1" />
+</component>

packaging/ink-notes.desktop

@@ -4,7 +4,7 @@ Name=ink-notes
 GenericName=Notizbuch- & Inking-App
 Comment=Latenzoptimierte Vektor-Notizen mit Stylus, Stift & Geometrie-Erkennung
 Exec=ink-notes %F
-Icon=ink-notes
+Icon=eu.pansi.ink-notes
 Terminal=false
 Type=Application
 Categories=Office;Graphics;Utility;

packaging/ink-notes.metainfo.xml

@@ -20,7 +20,7 @@
       <li>Vektor-PDF-Export für Druck und Weitergabe</li>
     </ul>
   </description>
-  <launchable type="desktop-id">ink-notes.desktop</launchable>
+  <launchable type="desktop-id">eu.pansi.ink-notes.desktop</launchable>
   <provides>
     <binary>ink-notes</binary>
   </provides>
@@ -32,7 +32,7 @@
   <developer id="eu.pansi">
     <name>Harald</name>
   </developer>
-  <url type="homepage">https://farmersdog.pansi.eu/harald/ink-notes</url>
-  <url type="bugtracker">https://farmersdog.pansi.eu/harald/ink-notes/issues</url>
+  <url type="homepage">https://gitea.pansi.eu/harald/ink-notes</url>
+  <url type="bugtracker">https://gitea.pansi.eu/harald/ink-notes/issues</url>
   <content_rating type="oars-1.1" />
 </component>

packaging/release-notes.md.tmpl

@@ -0,0 +1,39 @@
+## ink-notes {{TAG_NAME}}
+
+Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux (Zorin OS 18 / Ubuntu 24.04).
+
+### Highlights:
+- **Teilstrich-Radierer**: Nur den überstrichenen Teil eines Strichs entfernen – ein Radierzug ist ein Undo-Schritt
+- **Export & Zwischenablage**: Aktuelle Seite als PNG (auch transparent) oder SVG; Strg+C legt die Auswahl zusätzlich als Bild in die Zwischenablage für Chat, Mail oder Office
+- **Seitentitel & Inhaltsverzeichnis**: Seiten benennen, Inhaltsansicht in der Seitenübersicht, Titel werden zu PDF-Lesezeichen (Dateiformat-Version 6)
+- **PDF importieren & annotieren**: Vorlesungsfolien, Übungsblätter oder Formulare als neues Notizbuch öffnen (☰-Menü oder Drag & Drop), darauf schreiben und markieren; beim Export liegen die Originalseiten verlustfrei als Vektor unter den Notizen (Dateiformat-Version 5: ältere Versionen öffnen solche Notizbücher nicht)
+- **Bilder einfügen**: Screenshots per Strg+V, Bilddateien über die eingebaute Dateiauswahl (Strg+I) oder per Drag & Drop; verschieben, drehen, skalieren und darauf schreiben – auch im PDF-Export (Dateiformat-Version 4: ältere Versionen öffnen solche Notizbücher nicht)
+- **Dunkelmodus & Papierfarben**: Weiß, Creme, Dunkelgrau oder Schwarz; auf dunklem Papier werden dunkle Stiftfarben automatisch aufgehellt (nur Anzeige – Dateien und PDF-Export bleiben unverändert)
+- **Nur Textmarker radieren**: Markierungen korrigieren, ohne die Handschrift darunter zu löschen – auch mit Stiftrückseite und Seitentaste
+- **Einstellbare Druckkurve**: Kennlinie weich bis hart und Mindestdruck mit Live-Vorschau, passend für jeden Digitizer
+- **Neue Formen**: Ellipsen sowie in einem Zug gezeichnete Pfeile und Doppelpfeile werden erkannt (Dateiformat-Version 3: ältere Versionen öffnen solche Notizbücher nicht)
+- **Stabiler Start**: Kein Absturz mehr, wenn die Grafikkarte nicht nutzbar ist (z. B. fehlende Rechte auf /dev/dri); Software-Renderer als Ausweichlösung und verständliche Fehlermeldung
+- **WSL (WSLg)**: Läuft unter WSL automatisch über X11 statt Wayland, da WSLg die Wayland-Verbindung abbricht; übersteuerbar mit `INK_NOTES_DISPLAY=x11|wayland`
+- **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, Pfeile & Doppelpfeile, Rechtecke, Kreise, Ellipsen, Dreiecke, Rauten, Vielecke & Koordinatensysteme mit spitzen Pfeilspitzen (Draw-and-Hold); Freiformen bleiben unverändert
+- **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:
+- **Zorin OS / Ubuntu / Debian (.deb)**:
+  ```bash
+  sudo dpkg -i ink-notes_{{VERSION}}_amd64.deb
+  ```
+- **Portables AppImage (Alle Linux-Distributionen)**:
+  ```bash
+  chmod +x ink-notes_{{VERSION}}_x86_64.AppImage
+  ./ink-notes_{{VERSION}}_x86_64.AppImage
+  ```

scripts/build-release.sh

@@ -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}"

scripts/crash-test.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+# ==============================================================================
+# scripts/crash-test.sh
+# Stresstest für ink-notes Speicher- und Autosave-Robustheit.
+# Simuliert harte Programmabstürze (SIGKILL / kill -9) während Schreibvorgängen
+# und verifiziert die Integrität der Notizbücher und Seiten.
+# ==============================================================================
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+ITERATIONS="${1:-200}"
+TEST_DIR="${REPO_ROOT}/target/crash_test_workspace"
+CRASH_SIM_BIN="${REPO_ROOT}/target/release/crash_sim"
+
+echo "=================================================================="
+echo " ink-notes Crash- & Datenverlust-Stresstest"
+echo " Iterationen: ${ITERATIONS}"
+echo " Testverzeichnis: ${TEST_DIR}"
+echo "=================================================================="
+
+# 1. Sicherstellen, dass das Test-Binary gebaut ist
+if [ ! -f "${CRASH_SIM_BIN}" ]; then
+    echo "Baue crash_sim Release-Binary..."
+    cargo build --release --bin crash_sim --manifest-path "${REPO_ROOT}/Cargo.toml"
+fi
+
+# 2. Sauberes Testverzeichnis anlegen und Notizbuch initialisieren
+rm -rf "${TEST_DIR}"
+mkdir -p "${TEST_DIR}"
+"${CRASH_SIM_BIN}" init "${TEST_DIR}"
+
+SUCCESS_COUNT=0
+INTERRUPTED_WRITES=0
+
+trap 'rm -rf "${TEST_DIR}"' EXIT
+
+echo "Starte Testlauf mit ${ITERATIONS} SIGKILL-Zyklen..."
+
+for i in $(seq 1 "${ITERATIONS}"); do
+    # Worker im Hintergrund starten
+    "${CRASH_SIM_BIN}" worker "${TEST_DIR}" > /dev/null 2>&1 &
+    WORKER_PID=$!
+
+    # Zufällige Schlafdauer zwischen 2ms und 35ms, um Schreiboperationen mitten im Flug zu treffen
+    # RANDOM % 33 + 2 ergibt 2..34 Millisekunden
+    MS_DELAY=$(( (RANDOM % 33) + 2 ))
+    DELAY="0.$(printf "%03d" "$MS_DELAY")"
+    sleep "${DELAY}"
+
+    # Harter Prozessabbruch ohne Clean-up (SIGKILL)
+    if kill -9 "${WORKER_PID}" 2>/dev/null; then
+        INTERRUPTED_WRITES=$((INTERRUPTED_WRITES + 1))
+    fi
+    wait "${WORKER_PID}" 2>/dev/null || true
+
+    # Integritäts- und Konsistenzprüfung
+    if ! "${CRASH_SIM_BIN}" verify "${TEST_DIR}" > /dev/null 2>&1; then
+        echo ""
+        echo "❌ FEHLER in Iteration ${i}!"
+        echo "Notizbuch im Zustand nach Absturz nicht konsistent ladbar!"
+        "${CRASH_SIM_BIN}" verify "${TEST_DIR}" || true
+        trap - EXIT
+        exit 1
+    fi
+
+    SUCCESS_COUNT=$((SUCCESS_COUNT + 1))
+    if [ $((i % 25)) -eq 0 ] || [ "${i}" -eq "${ITERATIONS}" ]; then
+        echo "  [$(date +%T)] Iteration ${i}/${ITERATIONS} bestanden (erfolgreich unterbrochene Schreibvorgänge: ${INTERRUPTED_WRITES})."
+    fi
+done
+
+echo ""
+echo "=================================================================="
+echo "✅ ALLE ${ITERATIONS} CRASH-TESTS ERFOLGREICH BESTANDEN!"
+echo "   - Überstandene SIGKILLs: ${INTERRUPTED_WRITES}"
+echo "   - Konsistente Ladevorgänge: ${SUCCESS_COUNT}/${ITERATIONS}"
+echo "   - Keine korrupten JSON-Dateien ohne Quarantäne"
+echo "   - Keine unvollständigen Atom-Schreibungen"
+echo "=================================================================="

scripts/package-appimage.sh

@@ -18,11 +18,22 @@ APPDIR="${ROOT_DIR}/target/AppDir"
 CACHE_DIR="${ROOT_DIR}/target/tools"
 APPIMAGETOOL="${CACHE_DIR}/appimagetool-x86_64.AppImage"
 
+# Pinned appimagetool Release & SHA-256 Hash
+APPIMAGETOOL_VERSION="1.9.1"
+APPIMAGETOOL_URL="https://github.com/AppImage/appimagetool/releases/download/${APPIMAGETOOL_VERSION}/appimagetool-x86_64.AppImage"
+APPIMAGETOOL_SHA256="ed4ce84f0d9caff66f50bcca6ff6f35aae54ce8135408b3fa33abfc3cb384eb0"
+
 echo "=== [1/5] Stelle Release-Binary sicher (ink-notes v${VERSION}) ==="
 if [ ! -f "target/release/ink-notes" ]; then
     cargo build --release
 fi
 
+# Prüfe glibc-Mindestversion
+echo "=== Prüfe glibc-Symbolversionen ==="
+MAX_GLIBC=$(objdump -T "target/release/ink-notes" | grep "GLIBC_" | sed -e 's/.*GLIBC_//' | cut -d')' -f1 | sort -V | tail -n 1 || echo "unknown")
+echo "Höchste benötigte glibc-Symbolversion: GLIBC_${MAX_GLIBC}"
+echo "Hinweis: ink-notes nutzt den Host-Grafikstack (Vulkan ICD, Wayland/X11) und glibc >= ${MAX_GLIBC}."
+
 # Sicherstellen, dass das PNG-Icon existiert
 if [ ! -f "assets/ink-notes.png" ]; then
     echo "Generiere PNG-Icon..."
@@ -41,15 +52,20 @@ mkdir -p "${APPDIR}/usr/share/metainfo"
 cp "target/release/ink-notes" "${APPDIR}/usr/bin/ink-notes"
 chmod 755 "${APPDIR}/usr/bin/ink-notes"
 
-cp "packaging/ink-notes.desktop" "${APPDIR}/usr/share/applications/ink-notes.desktop"
-cp "packaging/ink-notes.desktop" "${APPDIR}/ink-notes.desktop"
+# Desktop-Datei
+cp "packaging/eu.pansi.ink-notes.desktop" "${APPDIR}/usr/share/applications/eu.pansi.ink-notes.desktop"
+cp "packaging/eu.pansi.ink-notes.desktop" "${APPDIR}/eu.pansi.ink-notes.desktop"
+ln -sf "eu.pansi.ink-notes.desktop" "${APPDIR}/ink-notes.desktop"
 
-cp "assets/ink-notes.svg" "${APPDIR}/usr/share/icons/hicolor/scalable/apps/ink-notes.svg"
-cp "assets/ink-notes.png" "${APPDIR}/usr/share/icons/hicolor/256x256/apps/ink-notes.png"
-cp "assets/ink-notes.png" "${APPDIR}/ink-notes.png"
-ln -sf "ink-notes.png" "${APPDIR}/.DirIcon"
+# Icons
+cp "assets/ink-notes.svg" "${APPDIR}/usr/share/icons/hicolor/scalable/apps/eu.pansi.ink-notes.svg"
+cp "assets/ink-notes.png" "${APPDIR}/usr/share/icons/hicolor/256x256/apps/eu.pansi.ink-notes.png"
+cp "assets/ink-notes.png" "${APPDIR}/eu.pansi.ink-notes.png"
+ln -sf "eu.pansi.ink-notes.png" "${APPDIR}/.DirIcon"
 
-cp "packaging/ink-notes.metainfo.xml" "${APPDIR}/usr/share/metainfo/eu.pansi.ink-notes.metainfo.xml"
+# Metainfo
+cp "packaging/eu.pansi.ink-notes.metainfo.xml" "${APPDIR}/usr/share/metainfo/eu.pansi.ink-notes.metainfo.xml"
+cp "packaging/eu.pansi.ink-notes.metainfo.xml" "${APPDIR}/usr/share/metainfo/eu.pansi.ink-notes.appdata.xml"
 
 # AppRun Skript erstellen
 cat <<'EOF' > "${APPDIR}/AppRun"
@@ -62,11 +78,32 @@ exec "${SELF_DIR}/usr/bin/ink-notes" "$@"
 EOF
 chmod 755 "${APPDIR}/AppRun"
 
-echo "=== [3/5] Hole appimagetool (gecacht in ${CACHE_DIR}) ==="
+echo "=== [3/5] Hole & verifiziere gepinntes appimagetool v${APPIMAGETOOL_VERSION} ==="
 mkdir -p "${CACHE_DIR}"
-if [ ! -f "${APPIMAGETOOL}" ]; then
-    echo "Lade appimagetool herunter..."
-    curl -fsSL -o "${APPIMAGETOOL}" "https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage"
+
+need_download=true
+if [ -f "${APPIMAGETOOL}" ]; then
+    CURRENT_HASH=$(sha256sum "${APPIMAGETOOL}" | cut -d' ' -f1)
+    if [ "${CURRENT_HASH}" = "${APPIMAGETOOL_SHA256}" ]; then
+        need_download=false
+    else
+        echo "Gecachtes appimagetool hat ungültigen Hash. Lade neu herunter..."
+        rm -f "${APPIMAGETOOL}"
+    fi
+fi
+
+if [ "${need_download}" = true ]; then
+    echo "Lade appimagetool v${APPIMAGETOOL_VERSION} herunter..."
+    curl -fsSL -o "${APPIMAGETOOL}.tmp" "${APPIMAGETOOL_URL}"
+    DOWNLOAD_HASH=$(sha256sum "${APPIMAGETOOL}.tmp" | cut -d' ' -f1)
+    if [ "${DOWNLOAD_HASH}" != "${APPIMAGETOOL_SHA256}" ]; then
+        echo "FEHLER: SHA256-Prüfsumme für appimagetool stimmt nicht überein!"
+        echo "Erwartet: ${APPIMAGETOOL_SHA256}"
+        echo "Erhalten: ${DOWNLOAD_HASH}"
+        rm -f "${APPIMAGETOOL}.tmp"
+        exit 1
+    fi
+    mv "${APPIMAGETOOL}.tmp" "${APPIMAGETOOL}"
     chmod +x "${APPIMAGETOOL}"
 fi
 

scripts/package-deb.sh

@@ -16,7 +16,7 @@ ARCH="amd64"
 DEB_NAME="${PKG_NAME}_${VERSION}_${ARCH}.deb"
 STAGING_DIR="${ROOT_DIR}/target/deb_staging"
 
-echo "=== [1/4] Baue Release-Binary mit Cargo (ink-notes v${VERSION}) ==="
+echo "=== [1/5] Baue Release-Binary mit Cargo (ink-notes v${VERSION}) ==="
 cargo build --release
 
 # Sicherstellen, dass das PNG-Icon existiert
@@ -25,7 +25,23 @@ if [ ! -f "assets/ink-notes.png" ]; then
     python3 scripts/generate_png_icon.py
 fi
 
-echo "=== [2/4] Erstelle Paketstruktur in ${STAGING_DIR} ==="
+echo "=== [2/5] Ermittle tatsächliche Abhängigkeiten (ldd & dpkg-shlibdeps) ==="
+echo "Linker-Abhängigkeiten (ldd):"
+ldd target/release/ink-notes
+
+if command -v dpkg-shlibdeps >/dev/null 2>&1; then
+    echo "Ermittle automatische shlibdeps via dpkg-shlibdeps..."
+    TEMP_CONTROL_DIR="$(mktemp -d)"
+    mkdir -p "${TEMP_CONTROL_DIR}/debian"
+    echo "Source: ${PKG_NAME}" > "${TEMP_CONTROL_DIR}/debian/control"
+    (
+        cd "${TEMP_CONTROL_DIR}"
+        dpkg-shlibdeps -O "${ROOT_DIR}/target/release/ink-notes" 2>/dev/null || true
+    )
+    rm -rf "${TEMP_CONTROL_DIR}"
+fi
+
+echo "=== [3/5] Erstelle Paketstruktur in ${STAGING_DIR} ==="
 rm -rf "${STAGING_DIR}"
 mkdir -p "${STAGING_DIR}/DEBIAN"
 mkdir -p "${STAGING_DIR}/usr/bin"
@@ -33,44 +49,104 @@ mkdir -p "${STAGING_DIR}/usr/share/applications"
 mkdir -p "${STAGING_DIR}/usr/share/icons/hicolor/scalable/apps"
 mkdir -p "${STAGING_DIR}/usr/share/icons/hicolor/256x256/apps"
 mkdir -p "${STAGING_DIR}/usr/share/metainfo"
+mkdir -p "${STAGING_DIR}/usr/share/doc/${PKG_NAME}"
 
-# 2. Dateien kopieren
+# Dateien kopieren
 cp "target/release/ink-notes" "${STAGING_DIR}/usr/bin/ink-notes"
+
+# Desktop-Dateien (sowohl mit AppStream ID als auch Legacy Name)
+cp "packaging/eu.pansi.ink-notes.desktop" "${STAGING_DIR}/usr/share/applications/eu.pansi.ink-notes.desktop"
+cp "packaging/eu.pansi.ink-notes.desktop" "${STAGING_DIR}/usr/share/applications/ink-notes.desktop"
+
+# Icons (eu.pansi.ink-notes & ink-notes)
+cp "assets/ink-notes.svg" "${STAGING_DIR}/usr/share/icons/hicolor/scalable/apps/eu.pansi.ink-notes.svg"
+cp "assets/ink-notes.svg" "${STAGING_DIR}/usr/share/icons/hicolor/scalable/apps/ink-notes.svg"
+cp "assets/ink-notes.png" "${STAGING_DIR}/usr/share/icons/hicolor/256x256/apps/eu.pansi.ink-notes.png"
+cp "assets/ink-notes.png" "${STAGING_DIR}/usr/share/icons/hicolor/256x256/apps/ink-notes.png"
+
+# AppStream Metainfo
+cp "packaging/eu.pansi.ink-notes.metainfo.xml" "${STAGING_DIR}/usr/share/metainfo/eu.pansi.ink-notes.metainfo.xml"
+
+# Debian doc: copyright
+cat <<'EOF' > "${STAGING_DIR}/usr/share/doc/ink-notes/copyright"
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: ink-notes
+Upstream-Contact: Harald <harald@pansi.eu>
+Source: https://gitea.pansi.eu/harald/ink-notes
+
+Files: *
+Copyright: 2026 Harald Pansi <harald@pansi.eu>
+License: MIT
+
+License: MIT
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ .
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+ .
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+EOF
+
+# Debian doc: changelog.gz
+CHANGELOG_TMP="$(mktemp)"
+cat <<EOF > "${CHANGELOG_TMP}"
+ink-notes (${VERSION}-1) stable; urgency=medium
+
+  * Release v${VERSION}.
+  * Low-latency vector inking with two-stage pipeline.
+  * Shape recognition and infinite canvas with zoom/pan.
+  * Multi-notebook management and PDF export.
+
+ -- Harald <harald@pansi.eu>  $(date -R)
+EOF
+gzip -n -9 -c "${CHANGELOG_TMP}" > "${STAGING_DIR}/usr/share/doc/ink-notes/changelog.gz"
+rm -f "${CHANGELOG_TMP}"
+
+# Berechtigungen penibel setzen
+find "${STAGING_DIR}" -type d -exec chmod 755 {} +
+find "${STAGING_DIR}/usr/share" -type f -exec chmod 644 {} +
+chmod 755 "${STAGING_DIR}/DEBIAN"
 chmod 755 "${STAGING_DIR}/usr/bin/ink-notes"
 
-cp "packaging/ink-notes.desktop" "${STAGING_DIR}/usr/share/applications/ink-notes.desktop"
-chmod 644 "${STAGING_DIR}/usr/share/applications/ink-notes.desktop"
-
-cp "assets/ink-notes.svg" "${STAGING_DIR}/usr/share/icons/hicolor/scalable/apps/ink-notes.svg"
-chmod 644 "${STAGING_DIR}/usr/share/icons/hicolor/scalable/apps/ink-notes.svg"
-
-cp "assets/ink-notes.png" "${STAGING_DIR}/usr/share/icons/hicolor/256x256/apps/ink-notes.png"
-chmod 644 "${STAGING_DIR}/usr/share/icons/hicolor/256x256/apps/ink-notes.png"
-
-cp "packaging/ink-notes.metainfo.xml" "${STAGING_DIR}/usr/share/metainfo/eu.pansi.ink-notes.metainfo.xml"
-chmod 644 "${STAGING_DIR}/usr/share/metainfo/eu.pansi.ink-notes.metainfo.xml"
-
-# 3. DEBIAN/control Datei generieren
+# DEBIAN/control Datei generieren
 cat <<EOF > "${STAGING_DIR}/DEBIAN/control"
 Package: ${PKG_NAME}
 Version: ${VERSION}
 Architecture: ${ARCH}
 Maintainer: Harald <harald@pansi.eu>
 Installed-Size: $(du -ks "${STAGING_DIR}/usr" | cut -f1)
-Depends: libc6, libx11-6, libxcursor1, libxrandr2, libxi6, libxkbcommon0
+Depends: libc6 (>= 2.38), libgcc-s1, libvulkan1, mesa-vulkan-drivers | vulkan-icd, libwayland-client0, libx11-6, libxcursor1, libxrandr2, libxi6, libxkbcommon0, xdg-utils
 Section: utils
 Priority: optional
-Homepage: https://farmersdog.pansi.eu/harald/ink-notes
+Homepage: https://gitea.pansi.eu/harald/ink-notes
 Description: Latenzoptimierte Vektor-Notizbuch- und Inking-App für Linux
  ink-notes kombiniert minimale Stylus-Latenz mit GPU-Hardwarebeschleunigung (wgpu),
  stufenlosem Viewport, Geometrie- und Formerkennung, Objekt-Transformationen,
  Multi-Dokumenten-Verwaltung und Vektor-PDF-Export.
 EOF
+chmod 644 "${STAGING_DIR}/DEBIAN/control"
 
-echo "=== [3/4] Schnüre .deb-Paket mit dpkg-deb ==="
+echo "=== [4/5] Schnüre .deb-Paket mit dpkg-deb ==="
 dpkg-deb --build --root-owner-group "${STAGING_DIR}" "${ROOT_DIR}/target/${DEB_NAME}"
 
-echo "=== [4/4] Paket erfolgreich erstellt: target/${DEB_NAME} ==="
+echo "=== [5/5] Paket erfolgreich erstellt: target/${DEB_NAME} ==="
 ls -lh "${ROOT_DIR}/target/${DEB_NAME}"
 dpkg-deb -I "${ROOT_DIR}/target/${DEB_NAME}"
+
+if command -v lintian >/dev/null 2>&1; then
+    echo "=== Prüfe Paket mit lintian ==="
+    lintian "${ROOT_DIR}/target/${DEB_NAME}" || true
+fi
+
 echo "Fertig!"

scripts/publish-gitea-release.sh

@@ -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 als Release-Assets hoch.
+# Lädt .deb, .AppImage, SHA256SUMS.txt und SHA256SUMS.txt.minisig idempotent als Release-Assets hoch.
 # ==============================================================================
 set -euo pipefail
 
@@ -14,13 +14,15 @@ GITEA_SERVER="${GITEA_SERVER:-https://gitea.pansi.eu}"
 REPO_OWNER="${REPO_OWNER:-harald}"
 REPO_NAME="${REPO_NAME:-ink-notes}"
 
-# Token aus Argument oder Umgebungsvariablen ermitteln
-TOKEN="${1:-${INK_NOTES_GITEA_TOKEN:-${GITEA_TOKEN:-${GITHUB_TOKEN:-}}}}"
+# Token ausschließlich aus Umgebungsvariablen ermitteln (Fallback für Legacy-Aufruf mit Argument)
+TOKEN="${INK_NOTES_GITEA_TOKEN:-${GITEA_TOKEN:-${GITHUB_TOKEN:-}}}"
+if [ -z "${TOKEN}" ] && [ -n "${1:-}" ]; then
+    TOKEN="$1"
+fi
 
 if [ -z "${TOKEN}" ]; then
     echo "FEHLER: Kein Gitea-API-Token angegeben."
-    echo "Verwendung: $0 <GITEA_API_TOKEN>"
-    echo "Oder setze die Umgebungsvariable INK_NOTES_GITEA_TOKEN."
+    echo "Bitte setze die Umgebungsvariable GITEA_TOKEN oder INK_NOTES_GITEA_TOKEN."
     exit 1
 fi
 
@@ -31,6 +33,13 @@ 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
+    echo "FEHLER: Release-Template '${TEMPLATE_FILE}' nicht gefunden."
+    exit 1
+fi
 
 # Sicherstellen, dass die Artefakte existieren
 if [ ! -f "${DEB_FILE}" ] || [ ! -f "${APPIMAGE_FILE}" ] || [ ! -f "${CHECKSUMS_FILE}" ]; then
@@ -38,101 +47,197 @@ 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 "======================================================================"
 
-RELEASE_BODY=$(cat <<EOF
-## ink-notes ${TAG_NAME}
-
-Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux (Zorin OS 18 / Ubuntu 24.04).
-
-### Highlights:
-- **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)
-- **Viewport**: Stufenloser Zoom (25% - 500%) und Panning
-- **Multi-Dokumenten-Manager**: Unbegrenzte Notizbücher mit atomarem Autosave
-- **In-App Updater**: Automatische Versionsprüfung und Aktualisierung via Gitea Releases
-- **Vektor-PDF-Export**: Verluste freie Ausgabe für Druck und Weitergabe
-
-### Installation:
-- **Zorin OS / Ubuntu / Debian (.deb)**:
-  \`\`\`bash
-  sudo dpkg -i ink-notes_${VERSION}_amd64.deb
-  \`\`\`
-- **Portables AppImage (Alle Linux-Distributionen)**:
-  \`\`\`bash
-  chmod +x ink-notes_${VERSION}_x86_64.AppImage
-  ./ink-notes_${VERSION}_x86_64.AppImage
-  \`\`\`
-EOF
-)
-
-# 1. Release via Gitea REST API erstellen (oder ID abfragen, falls bereits existent)
-CREATE_PAYLOAD=$(python3 -c "
-import json, sys
-data = {
-    'tag_name': '${TAG_NAME}',
-    'target_commitish': 'main',
-    'name': '${RELEASE_TITLE}',
-    'body': '''${RELEASE_BODY}''',
-    'draft': False,
-    'prerelease': False
+# 1. Payload robust per Python aus Template erzeugen (verhindert Shell-Escaping-Probleme)
+PAYLOAD_FILE="$(mktemp)"
+CLEANUP_FILES=("${PAYLOAD_FILE}")
+cleanup() {
+    for f in "${CLEANUP_FILES[@]}"; do
+        rm -f "${f}"
+    done
 }
-print(json.dumps(data))
-")
+trap cleanup EXIT
+
+RELEASE_VERSION="${VERSION}" RELEASE_TAG="${TAG_NAME}" RELEASE_TITLE="${RELEASE_TITLE}" \
+python3 -c '
+import json, os, sys
+
+template_path = sys.argv[1]
+with open(template_path, "r", encoding="utf-8") as f:
+    template_content = f.read()
+
+version = os.environ.get("RELEASE_VERSION", "")
+tag = os.environ.get("RELEASE_TAG", "")
+title = os.environ.get("RELEASE_TITLE", "")
+
+body = template_content.replace("{{VERSION}}", version).replace("{{TAG_NAME}}", tag)
+
+payload = {
+    "tag_name": tag,
+    "target_commitish": "main",
+    "name": title,
+    "body": body,
+    "draft": False,
+    "prerelease": False
+}
+print(json.dumps(payload))
+' "${TEMPLATE_FILE}" > "${PAYLOAD_FILE}"
 
 API_BASE="${GITEA_SERVER}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}"
 
-echo "Erstelle Release über Gitea API..."
-HTTP_RESPONSE=$(curl -s -w "\nHTTP_STATUS:%{http_code}" \
-    -X POST "${API_BASE}/releases" \
-    -H "Accept: application/json" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: token ${TOKEN}" \
-    -d "${CREATE_PAYLOAD}")
+# 2. Prüfen, ob Release bereits existiert (Idempotenz)
+echo "Prüfe bestehende Releases auf ${GITEA_SERVER}..."
+TAG_RESP_FILE="$(mktemp)"
+CLEANUP_FILES+=("${TAG_RESP_FILE}")
 
-HTTP_STATUS=$(echo "${HTTP_RESPONSE}" | grep "HTTP_STATUS:" | cut -d':' -f2)
-RESPONSE_BODY=$(echo "${HTTP_RESPONSE}" | sed '/HTTP_STATUS:/d')
+HTTP_STATUS=$(curl -s -S -o "${TAG_RESP_FILE}" -w "%{http_code}" \
+    -X GET "${API_BASE}/releases/tags/${TAG_NAME}" \
+    -H "Accept: application/json" \
+    -H "Authorization: token ${TOKEN}" || echo "000")
 
 RELEASE_ID=""
-if [ "${HTTP_STATUS}" -eq 201 ]; then
-    RELEASE_ID=$(echo "${RESPONSE_BODY}" | python3 -c "import sys, json; print(json.load(sys.stdin)['id'])")
-    echo "Release erfolgreich angelegt (ID: ${RELEASE_ID})!"
-else
-    echo "Release existiert womöglich bereits (Status ${HTTP_STATUS}). Suche bestehendes Release..."
-    EXISTING_RELEASE=$(curl -fsSL \
-        -H "Accept: application/json" \
-        -H "Authorization: token ${TOKEN}" \
-        "${API_BASE}/releases/tags/${TAG_NAME}" || true)
-    if [ -n "${EXISTING_RELEASE}" ]; then
-        RELEASE_ID=$(echo "${EXISTING_RELEASE}" | python3 -c "import sys, json; print(json.load(sys.stdin).get('id', ''))")
-    fi
-fi
 
-if [ -z "${RELEASE_ID}" ]; then
-    echo "FEHLER: Konnte Release nicht erstellen oder abfragen. Serverantwort:"
-    echo "${RESPONSE_BODY}"
+if [ "${HTTP_STATUS}" = "200" ]; then
+    RELEASE_ID=$(python3 -c '
+import sys, json
+try:
+    data = json.load(open(sys.argv[1]))
+    print(data.get("id", ""))
+except Exception:
+    pass
+' "${TAG_RESP_FILE}")
+    echo "Release ${TAG_NAME} existiert bereits (ID: ${RELEASE_ID}). Aktualisiere Release-Notizen..."
+    PATCH_STATUS=$(curl -s -S -o /dev/null -w "%{http_code}" \
+        -X PATCH "${API_BASE}/releases/${RELEASE_ID}" \
+        -H "Accept: application/json" \
+        -H "Content-Type: application/json" \
+        -H "Authorization: token ${TOKEN}" \
+        -d @"${PAYLOAD_FILE}" || echo "000")
+    if [ "${PATCH_STATUS}" != "200" ]; then
+        echo "Hinweis: Aktualisierung der Metadaten ergab HTTP ${PATCH_STATUS}."
+    fi
+elif [ "${HTTP_STATUS}" = "404" ]; then
+    echo "Release existiert noch nicht. Erstelle neues Release ${TAG_NAME}..."
+    CREATE_RESP_FILE="$(mktemp)"
+    CLEANUP_FILES+=("${CREATE_RESP_FILE}")
+    CREATE_STATUS=$(curl -s -S -o "${CREATE_RESP_FILE}" -w "%{http_code}" \
+        -X POST "${API_BASE}/releases" \
+        -H "Accept: application/json" \
+        -H "Content-Type: application/json" \
+        -H "Authorization: token ${TOKEN}" \
+        -d @"${PAYLOAD_FILE}" || echo "000")
+
+    if [ "${CREATE_STATUS}" = "201" ]; then
+        RELEASE_ID=$(python3 -c '
+import sys, json
+try:
+    data = json.load(open(sys.argv[1]))
+    print(data.get("id", ""))
+except Exception:
+    pass
+' "${CREATE_RESP_FILE}")
+        echo "Release erfolgreich angelegt (ID: ${RELEASE_ID})!"
+    else
+        echo "FEHLER: Release konnte nicht angelegt werden (HTTP ${CREATE_STATUS})."
+        cat "${CREATE_RESP_FILE}"
+        exit 1
+    fi
+else
+    echo "FEHLER: Unerwartete Serverantwort beim Abfragen des Release-Tags (HTTP ${HTTP_STATUS})."
+    cat "${TAG_RESP_FILE}"
     exit 1
 fi
 
-# 2. Assets hochladen
+if [ -z "${RELEASE_ID}" ]; then
+    echo "FEHLER: Keine gültige Release-ID ermittelt."
+    exit 1
+fi
+
+# 3. Vorhandene Assets auflisten (um Dubletten vor Upload sauber zu löschen)
+ASSETS_LIST_FILE="$(mktemp)"
+CLEANUP_FILES+=("${ASSETS_LIST_FILE}")
+
+LIST_STATUS=$(curl -s -S -o "${ASSETS_LIST_FILE}" -w "%{http_code}" \
+    -X GET "${API_BASE}/releases/${RELEASE_ID}/assets" \
+    -H "Accept: application/json" \
+    -H "Authorization: token ${TOKEN}" || echo "000")
+
+if [ "${LIST_STATUS}" != "200" ]; then
+    echo "Hinweis: Konnte bestehende Assets nicht abrufen (HTTP ${LIST_STATUS})."
+fi
+
 upload_asset() {
     local file_path="$1"
-    local filename="$(basename "${file_path}")"
+    local filename
+    filename="$(basename "${file_path}")"
+
+    # Asset-Namen in URL URL-kodieren
+    local encoded_name
+    encoded_name=$(python3 -c 'import sys, urllib.parse; print(urllib.parse.quote(sys.argv[1]))' "${filename}")
+
+    # Prüfen, ob bereits Assets mit demselben Namen existieren (können mehrere sein)
+    local existing_ids=()
+    if [ -f "${ASSETS_LIST_FILE}" ] && [ -s "${ASSETS_LIST_FILE}" ]; then
+        mapfile -t existing_ids < <(python3 -c '
+import sys, json
+try:
+    assets = json.load(open(sys.argv[1]))
+    target = sys.argv[2]
+    for a in assets:
+        if a.get("name") == target and a.get("id"):
+            print(a.get("id"))
+except Exception:
+    pass
+' "${ASSETS_LIST_FILE}" "${filename}")
+    fi
+
+    for eid in "${existing_ids[@]}"; do
+        if [ -n "${eid}" ]; then
+            echo "Lösche bestehendes Asset '${filename}' (ID: ${eid}) vor Re-Upload..."
+            local del_status
+            del_status=$(curl -s -S -o /dev/null -w "%{http_code}" \
+                -X DELETE "${API_BASE}/releases/${RELEASE_ID}/assets/${eid}" \
+                -H "Authorization: token ${TOKEN}" || echo "000")
+            if [ "${del_status}" != "204" ] && [ "${del_status}" != "200" ]; then
+                echo "Warnung: Löschen von bestehendem Asset '${filename}' ergab HTTP ${del_status}."
+            fi
+        fi
+    done
+
     echo "Lade Asset hoch: ${filename}..."
-    curl -fsSL \
-        -X POST "${API_BASE}/releases/${RELEASE_ID}/assets?name=${filename}" \
+    local upload_res_file="$(mktemp)"
+    CLEANUP_FILES+=("${upload_res_file}")
+
+    local upload_status
+    upload_status=$(curl -s -S -o "${upload_res_file}" -w "%{http_code}" \
+        -X POST "${API_BASE}/releases/${RELEASE_ID}/assets?name=${encoded_name}" \
         -H "Accept: application/json" \
         -H "Authorization: token ${TOKEN}" \
         -H "Content-Type: application/octet-stream" \
-        --data-binary "@${file_path}" > /dev/null
-    echo "✓ ${filename} erfolgreich hochgeladen."
+        --data-binary "@${file_path}" || echo "000")
+
+    if [ "${upload_status}" = "201" ]; then
+        echo "✓ ${filename} erfolgreich hochgeladen."
+    else
+        echo "FEHLER: Asset-Upload für '${filename}' fehlgeschlagen (HTTP ${upload_status})."
+        cat "${upload_res_file}"
+        exit 1
+    fi
 }
 
 upload_asset "${DEB_FILE}"
 upload_asset "${APPIMAGE_FILE}"
 upload_asset "${CHECKSUMS_FILE}"
+upload_asset "${SIGNATURE_FILE}"
 
 echo "======================================================================"
 echo "Release ${TAG_NAME} erfolgreich veröffentlicht!"

src/assets.rs

@@ -0,0 +1,366 @@
+//! Eingebettete Bilder eines Notizbuchs (`<Notizbuch>/assets/`).
+//!
+//! Jedes Bild wird einmal unter dem SHA-256 seines Inhalts gespeichert (`<hash>.png` bzw.
+//! `<hash>.jpg`). Seiten verweisen nur auf diesen Namen; dasselbe Bild mehrfach einzufügen
+//! kostet keinen zusätzlichen Platz. Bilddateien werden nie gelöscht, damit Undo und
+//! Kopien auf anderen Seiten immer funktionieren.
+//!
+//! JPEG wird unverändert übernommen (verlustfrei, auch im PDF-Export); alle anderen Formate
+//! werden als PNG gespeichert.
+
+use std::io::Cursor;
+use std::path::{Path, PathBuf};
+
+use sha2::{Digest, Sha256};
+
+use crate::storage;
+
+/// Name des Unterordners mit den Bilddateien.
+pub const ASSETS_DIR: &str = "assets";
+/// Größte Kantenlänge eines eingefügten Bildes in Pixeln; größere Bilder werden verkleinert
+/// (8000 px ≈ 300 dpi über die doppelte A4-Breite – mehr ist auf einer Seite nie sichtbar).
+pub const MAX_IMPORT_DIMENSION: u32 = 8000;
+/// Größte Kantenlänge der Bildschirmdarstellung (GPU-Textur).
+pub const MAX_DISPLAY_DIMENSION: u32 = 2048;
+/// Größte Dateigröße beim Einfügen.
+pub const MAX_IMPORT_BYTES: usize = 64 * 1024 * 1024;
+
+/// Fehler beim Einfügen oder Laden eines Bildes.
+#[derive(Debug)]
+pub enum AssetError {
+    /// Format nicht unterstützt oder Datei beschädigt
+    Decode(String),
+    /// Datei zu groß
+    TooLarge(usize),
+    /// Ungültiger Asset-Name (z. B. manipulierte Seitendatei)
+    InvalidName(String),
+    Io(std::io::Error),
+}
+
+impl std::fmt::Display for AssetError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AssetError::Decode(msg) => write!(f, "Bild kann nicht gelesen werden: {msg}"),
+            AssetError::TooLarge(bytes) => write!(
+                f,
+                "Bild ist zu groß ({} MB, höchstens {} MB)",
+                bytes / (1024 * 1024),
+                MAX_IMPORT_BYTES / (1024 * 1024)
+            ),
+            AssetError::InvalidName(name) => write!(f, "Ungültiger Bildverweis '{name}'"),
+            AssetError::Io(e) => write!(f, "Ein-/Ausgabefehler: {e}"),
+        }
+    }
+}
+
+impl std::error::Error for AssetError {}
+
+impl From<std::io::Error> for AssetError {
+    fn from(e: std::io::Error) -> Self {
+        AssetError::Io(e)
+    }
+}
+
+/// Ergebnis eines erfolgreichen Imports.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImportedImage {
+    /// Dateiname im Asset-Ordner, z. B. `3f…a9.png`
+    pub asset: String,
+    pub width: u32,
+    pub height: u32,
+}
+
+/// Dekodiertes Bild in 8-Bit-RGBA (sRGB).
+#[derive(Debug, Clone, PartialEq)]
+pub struct RgbaImage {
+    pub width: u32,
+    pub height: u32,
+    pub pixels: Vec<u8>,
+}
+
+/// Prüft einen Asset-Namen: genau 64 Hex-Zeichen und `.png`, `.jpg` oder `.pdf`. Verhindert, dass
+/// eine manipulierte Seitendatei auf Dateien außerhalb des Asset-Ordners verweist.
+pub fn is_valid_asset_name(name: &str) -> bool {
+    let Some((hash, ext)) = name.split_once('.') else {
+        return false;
+    };
+    hash.len() == 64
+        && hash
+            .bytes()
+            .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
+        && matches!(ext, "png" | "jpg" | "pdf")
+}
+
+/// Bilddateien eines Notizbuchs.
+#[derive(Debug, Clone)]
+pub struct AssetStore {
+    dir: PathBuf,
+}
+
+impl AssetStore {
+    /// Asset-Ordner des Notizbuchs in `notebook_dir`.
+    pub fn new(notebook_dir: &Path) -> Self {
+        Self {
+            dir: notebook_dir.join(ASSETS_DIR),
+        }
+    }
+
+    pub fn dir(&self) -> &Path {
+        &self.dir
+    }
+
+    /// Pfad einer Bilddatei (nur für gültige Namen).
+    pub fn path_of(&self, asset: &str) -> Result<PathBuf, AssetError> {
+        if is_valid_asset_name(asset) {
+            Ok(self.dir.join(asset))
+        } else {
+            Err(AssetError::InvalidName(asset.to_string()))
+        }
+    }
+
+    /// Übernimmt eine Bilddatei (Inhalt einer PNG-, JPEG-, GIF-, WebP- oder BMP-Datei).
+    pub fn import_bytes(&self, bytes: &[u8]) -> Result<ImportedImage, AssetError> {
+        if bytes.len() > MAX_IMPORT_BYTES {
+            return Err(AssetError::TooLarge(bytes.len()));
+        }
+        let format = image::guess_format(bytes).map_err(|e| AssetError::Decode(e.to_string()))?;
+        let decoded = image::load_from_memory_with_format(bytes, format)
+            .map_err(|e| AssetError::Decode(e.to_string()))?;
+
+        let fits =
+            decoded.width() <= MAX_IMPORT_DIMENSION && decoded.height() <= MAX_IMPORT_DIMENSION;
+        if format == image::ImageFormat::Jpeg && fits {
+            // JPEG unverändert übernehmen (kein erneuter Qualitätsverlust)
+            return self.store(bytes, "jpg", decoded.width(), decoded.height());
+        }
+        let decoded = if fits {
+            decoded
+        } else {
+            decoded.resize(
+                MAX_IMPORT_DIMENSION,
+                MAX_IMPORT_DIMENSION,
+                image::imageops::FilterType::Triangle,
+            )
+        };
+        let png = encode_png(&decoded)?;
+        self.store(&png, "png", decoded.width(), decoded.height())
+    }
+
+    /// Übernimmt eine PDF-Datei unverändert (der Inhalt muss vorher geprüft sein).
+    pub fn import_pdf(&self, bytes: &[u8]) -> Result<String, AssetError> {
+        let hash = Sha256::digest(bytes);
+        let asset = format!("{}.pdf", hex(&hash));
+        let path = self.path_of(&asset)?;
+        if !path.exists() {
+            storage::atomic_write_file(&path, bytes)?;
+        }
+        Ok(asset)
+    }
+
+    /// Übernimmt rohe RGBA-Pixel (z. B. aus der Zwischenablage) als PNG.
+    pub fn import_rgba(
+        &self,
+        width: u32,
+        height: u32,
+        pixels: Vec<u8>,
+    ) -> Result<ImportedImage, AssetError> {
+        let buffer = image::RgbaImage::from_raw(width, height, pixels)
+            .ok_or_else(|| AssetError::Decode("Pixeldaten passen nicht zur Bildgröße".into()))?;
+        let mut decoded = image::DynamicImage::ImageRgba8(buffer);
+        if width > MAX_IMPORT_DIMENSION || height > MAX_IMPORT_DIMENSION {
+            decoded = decoded.resize(
+                MAX_IMPORT_DIMENSION,
+                MAX_IMPORT_DIMENSION,
+                image::imageops::FilterType::Triangle,
+            );
+        }
+        let png = encode_png(&decoded)?;
+        self.store(&png, "png", decoded.width(), decoded.height())
+    }
+
+    /// Kopiert ein Bild aus dem Asset-Ordner eines anderen Notizbuchs (Einfügen über
+    /// Notizbuchgrenzen hinweg). Ist es schon vorhanden, passiert nichts.
+    pub fn copy_from(&self, other: &AssetStore, asset: &str) -> Result<(), AssetError> {
+        let target = self.path_of(asset)?;
+        if target.exists() || other.dir == self.dir {
+            return Ok(());
+        }
+        let bytes = std::fs::read(other.path_of(asset)?)?;
+        storage::atomic_write_file(&target, &bytes)?;
+        Ok(())
+    }
+
+    /// Liest die gespeicherte Bilddatei unverändert.
+    pub fn read_bytes(&self, asset: &str) -> Result<Vec<u8>, AssetError> {
+        Ok(std::fs::read(self.path_of(asset)?)?)
+    }
+
+    /// Lädt ein Bild für die Bildschirmdarstellung, verkleinert auf höchstens
+    /// `max_dimension` Pixel Kantenlänge.
+    pub fn load_rgba(&self, asset: &str, max_dimension: u32) -> Result<RgbaImage, AssetError> {
+        let bytes = self.read_bytes(asset)?;
+        let mut decoded =
+            image::load_from_memory(&bytes).map_err(|e| AssetError::Decode(e.to_string()))?;
+        if decoded.width() > max_dimension || decoded.height() > max_dimension {
+            decoded = decoded.resize(
+                max_dimension,
+                max_dimension,
+                image::imageops::FilterType::Triangle,
+            );
+        }
+        let rgba = decoded.into_rgba8();
+        Ok(RgbaImage {
+            width: rgba.width(),
+            height: rgba.height(),
+            pixels: rgba.into_raw(),
+        })
+    }
+
+    fn store(
+        &self,
+        bytes: &[u8],
+        ext: &str,
+        width: u32,
+        height: u32,
+    ) -> Result<ImportedImage, AssetError> {
+        let hash = Sha256::digest(bytes);
+        let asset = format!("{}.{ext}", hex(&hash));
+        let path = self.path_of(&asset)?;
+        if !path.exists() {
+            storage::atomic_write_file(&path, bytes)?;
+        }
+        Ok(ImportedImage {
+            asset,
+            width,
+            height,
+        })
+    }
+}
+
+fn encode_png(image: &image::DynamicImage) -> Result<Vec<u8>, AssetError> {
+    let mut png = Vec::new();
+    image
+        .write_to(&mut Cursor::new(&mut png), image::ImageFormat::Png)
+        .map_err(|e| AssetError::Decode(e.to_string()))?;
+    Ok(png)
+}
+
+fn hex(bytes: &[u8]) -> String {
+    bytes.iter().map(|b| format!("{b:02x}")).collect()
+}
+
+/// Ist die Datei dem Namen nach ein unterstütztes Bild?
+pub fn is_supported_image_path(path: &Path) -> bool {
+    path.extension()
+        .and_then(|e| e.to_str())
+        .map(|e| {
+            matches!(
+                e.to_ascii_lowercase().as_str(),
+                "png" | "jpg" | "jpeg" | "gif" | "webp" | "bmp"
+            )
+        })
+        .unwrap_or(false)
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+
+    /// Kleines Testbild als Dateiinhalt im gewünschten Format.
+    pub(crate) fn sample_image_bytes(
+        width: u32,
+        height: u32,
+        format: image::ImageFormat,
+    ) -> Vec<u8> {
+        let img = image::RgbImage::from_fn(width, height, |x, y| {
+            image::Rgb([
+                (x * 255 / width.max(1)) as u8,
+                (y * 255 / height.max(1)) as u8,
+                90,
+            ])
+        });
+        let mut bytes = Vec::new();
+        image::DynamicImage::ImageRgb8(img)
+            .write_to(&mut Cursor::new(&mut bytes), format)
+            .unwrap();
+        bytes
+    }
+
+    #[test]
+    fn test_asset_names_are_validated() {
+        let hash = "a".repeat(64);
+        assert!(is_valid_asset_name(&format!("{hash}.png")));
+        assert!(is_valid_asset_name(&format!("{hash}.jpg")));
+        assert!(!is_valid_asset_name(&format!("{hash}.exe")));
+        assert!(!is_valid_asset_name("../../etc/passwd"));
+        assert!(!is_valid_asset_name(&format!("../{}.png", "a".repeat(61))));
+        assert!(!is_valid_asset_name(&format!("{}.png", "A".repeat(64))));
+        assert!(!is_valid_asset_name(""));
+
+        let store = AssetStore::new(Path::new("/tmp/nb"));
+        assert!(store.path_of("../manifest.json").is_err());
+    }
+
+    #[test]
+    fn test_import_png_jpeg_and_deduplicate() {
+        let dir = tempfile::tempdir().unwrap();
+        let store = AssetStore::new(dir.path());
+
+        let png = sample_image_bytes(40, 20, image::ImageFormat::Png);
+        let a = store.import_bytes(&png).unwrap();
+        assert_eq!((a.width, a.height), (40, 20));
+        assert!(a.asset.ends_with(".png"));
+        assert!(store.path_of(&a.asset).unwrap().exists());
+
+        // Gleiches Bild nochmals: gleicher Name, keine zweite Datei
+        let b = store.import_bytes(&png).unwrap();
+        assert_eq!(a, b);
+        assert_eq!(std::fs::read_dir(store.dir()).unwrap().count(), 1);
+
+        // JPEG bleibt byte-identisch
+        let jpg = sample_image_bytes(30, 30, image::ImageFormat::Jpeg);
+        let c = store.import_bytes(&jpg).unwrap();
+        assert!(c.asset.ends_with(".jpg"));
+        assert_eq!(store.read_bytes(&c.asset).unwrap(), jpg);
+
+        // BMP wird als PNG gespeichert
+        let bmp = sample_image_bytes(8, 4, image::ImageFormat::Bmp);
+        let d = store.import_bytes(&bmp).unwrap();
+        assert!(d.asset.ends_with(".png"));
+
+        let rgba = store.load_rgba(&a.asset, MAX_DISPLAY_DIMENSION).unwrap();
+        assert_eq!((rgba.width, rgba.height), (40, 20));
+        assert_eq!(rgba.pixels.len(), 40 * 20 * 4);
+        // Verkleinerung für die Anzeige behält das Seitenverhältnis
+        let small = store.load_rgba(&a.asset, 10).unwrap();
+        assert_eq!((small.width, small.height), (10, 5));
+    }
+
+    #[test]
+    fn test_import_rejects_garbage_and_copies_between_notebooks() {
+        let dir = tempfile::tempdir().unwrap();
+        let store = AssetStore::new(&dir.path().join("a"));
+        assert!(matches!(
+            store.import_bytes(b"kein Bild"),
+            Err(AssetError::Decode(_))
+        ));
+        assert!(store.import_rgba(4, 4, vec![0; 3]).is_err());
+
+        let imported = store.import_rgba(2, 2, vec![255; 16]).unwrap();
+        let other = AssetStore::new(&dir.path().join("b"));
+        assert!(other.read_bytes(&imported.asset).is_err());
+        other.copy_from(&store, &imported.asset).unwrap();
+        assert_eq!(
+            other.read_bytes(&imported.asset).unwrap(),
+            store.read_bytes(&imported.asset).unwrap()
+        );
+    }
+
+    #[test]
+    fn test_supported_image_paths() {
+        assert!(is_supported_image_path(Path::new("/x/Foto.JPG")));
+        assert!(is_supported_image_path(Path::new("a.webp")));
+        assert!(!is_supported_image_path(Path::new("a.pdf")));
+        assert!(!is_supported_image_path(Path::new("png")));
+    }
+}

src/background.rs

@@ -1,5 +1,7 @@
 //! Vektor-Generierung für DIN-A4-Seitenhintergründe (Kariert, Liniert, Punktraster, Blanko).
 
+use serde::{Deserialize, Serialize};
+
 use crate::canvas::InkVertex;
 use crate::document::{PageBackground, PAGE_HEIGHT, PAGE_WIDTH};
 
@@ -13,27 +15,99 @@ pub const GRID_5MM_SPACING: f32 = 50.0;
 /// Zeilenabstand für liniertes Papier (7.5 mm = 75 Einheiten).
 pub const LINED_SPACING: f32 = 75.0;
 
-/// Hellgraue Farbe für Hintergrundmuster (#E0E0E0).
-pub const BACKGROUND_PATTERN_COLOR: [f32; 4] = [0.88, 0.88, 0.88, 1.0];
-/// Papierweiß für das DIN-A4-Blatt (#FFFFFF).
-pub const PAPER_COLOR: [f32; 4] = [1.0, 1.0, 1.0, 1.0];
-/// Schreibtisch-Hintergrundfarbe (Letterbox-Bereich, #28282D).
-pub const DESK_COLOR: wgpu::Color = wgpu::Color {
-    r: 0.16,
-    g: 0.16,
-    b: 0.18,
-    a: 1.0,
-};
+/// Papierfarbe der Anzeige. Betrifft nur die Darstellung am Bildschirm; gespeicherte
+/// Strichfarben und der PDF-Export bleiben unverändert (weißes Papier).
+///
+/// Alle Farben sind linear (die Oberfläche ist sRGB, die Umrechnung macht die GPU).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PaperTheme {
+    #[default]
+    White,
+    /// Cremefarben (augenschonend, wie Recyclingpapier)
+    Cream,
+    /// Dunkelgrau (Nachtmodus)
+    DarkGray,
+    /// Schwarz (OLED)
+    Black,
+}
 
-/// Erzeugt die 6 Vertizes (2 Dreiecke) für das weiße DIN-A4-Papierblatt.
-pub fn generate_paper_quad() -> Vec<InkVertex> {
+impl PaperTheme {
+    pub const ALL: [PaperTheme; 4] = [
+        PaperTheme::White,
+        PaperTheme::Cream,
+        PaperTheme::DarkGray,
+        PaperTheme::Black,
+    ];
+
+    pub fn label(self) -> &'static str {
+        match self {
+            PaperTheme::White => "Weiß",
+            PaperTheme::Cream => "Creme",
+            PaperTheme::DarkGray => "Dunkelgrau",
+            PaperTheme::Black => "Schwarz",
+        }
+    }
+
+    /// Dunkles Papier: dunkle Tinte wird bei Bedarf aufgehellt.
+    pub fn is_dark(self) -> bool {
+        matches!(self, PaperTheme::DarkGray | PaperTheme::Black)
+    }
+
+    /// Farbe des Blatts.
+    pub fn paper_color(self) -> [f32; 4] {
+        match self {
+            PaperTheme::White => [1.0, 1.0, 1.0, 1.0],
+            // sRGB #FBF5E6
+            PaperTheme::Cream => [0.965, 0.913, 0.791, 1.0],
+            // sRGB #2B2B2E
+            PaperTheme::DarkGray => [0.024, 0.024, 0.027, 1.0],
+            PaperTheme::Black => [0.0, 0.0, 0.0, 1.0],
+        }
+    }
+
+    /// Farbe von Karos, Linien und Punkten.
+    pub fn pattern_color(self) -> [f32; 4] {
+        match self {
+            PaperTheme::White => [0.88, 0.88, 0.88, 1.0],
+            PaperTheme::Cream => [0.78, 0.72, 0.60, 1.0],
+            // sRGB #48484D bzw. #38383C
+            PaperTheme::DarkGray => [0.064, 0.064, 0.074, 1.0],
+            PaperTheme::Black => [0.040, 0.040, 0.045, 1.0],
+        }
+    }
+
+    /// Schreibtisch-Hintergrund um das Blatt; bei dunklem Papier noch dunkler, damit sich
+    /// das Blatt abhebt.
+    pub fn desk_color(self) -> wgpu::Color {
+        let (r, g, b) = match self {
+            PaperTheme::White | PaperTheme::Cream => (0.16, 0.16, 0.18),
+            PaperTheme::DarkGray => (0.004, 0.004, 0.005),
+            PaperTheme::Black => (0.03, 0.03, 0.035),
+        };
+        wgpu::Color { r, g, b, a: 1.0 }
+    }
+}
+
+/// Hellt dunkle Tinte für dunkles Papier auf: die HSL-Helligkeit L wird zu 1 − L gespiegelt,
+/// Farbton und Sättigung bleiben erhalten. Farben mit L ≥ 0.5 (Rot, Blau, Textmarker)
+/// bleiben unverändert. Muss mit `fs_ink` in `shader.wgsl` übereinstimmen.
+pub fn adapt_ink_color(color: [f32; 4]) -> [f32; 4] {
+    let max = color[0].max(color[1]).max(color[2]);
+    let min = color[0].min(color[1]).min(color[2]);
+    let lift = (1.0 - max - min).max(0.0);
+    [color[0] + lift, color[1] + lift, color[2] + lift, color[3]]
+}
+
+/// Erzeugt die 6 Vertizes (2 Dreiecke) für das DIN-A4-Papierblatt.
+pub fn generate_paper_quad(color: [f32; 4]) -> Vec<InkVertex> {
     vec![
-        InkVertex::new(0.0, 0.0, PAPER_COLOR),
-        InkVertex::new(PAGE_WIDTH, 0.0, PAPER_COLOR),
-        InkVertex::new(0.0, PAGE_HEIGHT, PAPER_COLOR),
-        InkVertex::new(0.0, PAGE_HEIGHT, PAPER_COLOR),
-        InkVertex::new(PAGE_WIDTH, 0.0, PAPER_COLOR),
-        InkVertex::new(PAGE_WIDTH, PAGE_HEIGHT, PAPER_COLOR),
+        InkVertex::new(0.0, 0.0, color),
+        InkVertex::new(PAGE_WIDTH, 0.0, color),
+        InkVertex::new(0.0, PAGE_HEIGHT, color),
+        InkVertex::new(0.0, PAGE_HEIGHT, color),
+        InkVertex::new(PAGE_WIDTH, 0.0, color),
+        InkVertex::new(PAGE_WIDTH, PAGE_HEIGHT, color),
     ]
 }
 
@@ -41,21 +115,22 @@ pub fn generate_paper_quad() -> Vec<InkVertex> {
 #[inline]
 fn push_quad(
     vertices: &mut Vec<InkVertex>,
+    color: [f32; 4],
     x_min: f32,
     y_min: f32,
     x_max: f32,
     y_max: f32,
 ) {
-    vertices.push(InkVertex::new(x_min, y_min, BACKGROUND_PATTERN_COLOR));
-    vertices.push(InkVertex::new(x_max, y_min, BACKGROUND_PATTERN_COLOR));
-    vertices.push(InkVertex::new(x_min, y_max, BACKGROUND_PATTERN_COLOR));
-    vertices.push(InkVertex::new(x_min, y_max, BACKGROUND_PATTERN_COLOR));
-    vertices.push(InkVertex::new(x_max, y_min, BACKGROUND_PATTERN_COLOR));
-    vertices.push(InkVertex::new(x_max, y_max, BACKGROUND_PATTERN_COLOR));
+    vertices.push(InkVertex::new(x_min, y_min, color));
+    vertices.push(InkVertex::new(x_max, y_min, color));
+    vertices.push(InkVertex::new(x_min, y_max, color));
+    vertices.push(InkVertex::new(x_min, y_max, color));
+    vertices.push(InkVertex::new(x_max, y_min, color));
+    vertices.push(InkVertex::new(x_max, y_max, color));
 }
 
-/// Generiert das statische Vektor-Mesh für den gewählten Seitenhintergrund.
-pub fn generate_background_mesh(background: PageBackground) -> Vec<InkVertex> {
+/// Generiert das statische Vektor-Mesh für den gewählten Seitenhintergrund in `color`.
+pub fn generate_background_mesh(background: PageBackground, color: [f32; 4]) -> Vec<InkVertex> {
     match background {
         PageBackground::Blank => Vec::new(),
         PageBackground::Grid5mm => {
@@ -65,14 +140,28 @@ pub fn generate_background_mesh(background: PageBackground) -> Vec<InkVertex> {
             // Vertikale Linien alle 5 mm
             let mut x = GRID_5MM_SPACING;
             while x < PAGE_WIDTH {
-                push_quad(&mut vertices, x - half_t, 0.0, x + half_t, PAGE_HEIGHT);
+                push_quad(
+                    &mut vertices,
+                    color,
+                    x - half_t,
+                    0.0,
+                    x + half_t,
+                    PAGE_HEIGHT,
+                );
                 x += GRID_5MM_SPACING;
             }
 
             // Horizontale Linien alle 5 mm
             let mut y = GRID_5MM_SPACING;
             while y < PAGE_HEIGHT {
-                push_quad(&mut vertices, 0.0, y - half_t, PAGE_WIDTH, y + half_t);
+                push_quad(
+                    &mut vertices,
+                    color,
+                    0.0,
+                    y - half_t,
+                    PAGE_WIDTH,
+                    y + half_t,
+                );
                 y += GRID_5MM_SPACING;
             }
 
@@ -88,7 +177,14 @@ pub fn generate_background_mesh(background: PageBackground) -> Vec<InkVertex> {
 
             let mut y = margin_top;
             while y <= PAGE_HEIGHT - margin_bottom {
-                push_quad(&mut vertices, 0.0, y - half_t, PAGE_WIDTH, y + half_t);
+                push_quad(
+                    &mut vertices,
+                    color,
+                    0.0,
+                    y - half_t,
+                    PAGE_WIDTH,
+                    y + half_t,
+                );
                 y += LINED_SPACING;
             }
 
@@ -102,7 +198,14 @@ pub fn generate_background_mesh(background: PageBackground) -> Vec<InkVertex> {
             while y < PAGE_HEIGHT {
                 let mut x = GRID_5MM_SPACING;
                 while x < PAGE_WIDTH {
-                    push_quad(&mut vertices, x - half_d, y - half_d, x + half_d, y + half_d);
+                    push_quad(
+                        &mut vertices,
+                        color,
+                        x - half_d,
+                        y - half_d,
+                        x + half_d,
+                        y + half_d,
+                    );
                     x += GRID_5MM_SPACING;
                 }
                 y += GRID_5MM_SPACING;
@@ -119,27 +222,87 @@ mod tests {
 
     #[test]
     fn test_paper_quad_generation() {
-        let quad = generate_paper_quad();
+        let quad = generate_paper_quad(PaperTheme::White.paper_color());
         assert_eq!(quad.len(), 6);
         assert_eq!(quad[0].position, [0.0, 0.0]);
         assert_eq!(quad[5].position, [PAGE_WIDTH, PAGE_HEIGHT]);
     }
 
+    const PATTERN: [f32; 4] = [0.5, 0.5, 0.5, 1.0];
+
     #[test]
     fn test_background_meshes() {
-        let blank = generate_background_mesh(PageBackground::Blank);
+        let blank = generate_background_mesh(PageBackground::Blank, PATTERN);
         assert!(blank.is_empty());
 
-        let grid = generate_background_mesh(PageBackground::Grid5mm);
+        let grid = generate_background_mesh(PageBackground::Grid5mm, PATTERN);
         assert!(!grid.is_empty());
-        assert_eq!(grid.len() % 6, 0, "Muss ein Vielfaches von 6 Vertizes sein (Dreiecke)");
+        assert_eq!(
+            grid.len() % 6,
+            0,
+            "Muss ein Vielfaches von 6 Vertizes sein (Dreiecke)"
+        );
 
-        let lined = generate_background_mesh(PageBackground::Lined);
+        let lined = generate_background_mesh(PageBackground::Lined, PATTERN);
         assert!(!lined.is_empty());
         assert_eq!(lined.len() % 6, 0);
 
-        let dots = generate_background_mesh(PageBackground::DotGrid);
+        let dots = generate_background_mesh(PageBackground::DotGrid, PATTERN);
         assert!(!dots.is_empty());
         assert_eq!(dots.len() % 6, 0);
     }
+
+    #[test]
+    fn test_background_mesh_uses_theme_color() {
+        let dark = PaperTheme::Black.pattern_color();
+        let mesh = generate_background_mesh(PageBackground::Lined, dark);
+        assert!(mesh.iter().all(|v| v.color == dark));
+        let quad = generate_paper_quad(PaperTheme::Cream.paper_color());
+        assert!(quad
+            .iter()
+            .all(|v| v.color == PaperTheme::Cream.paper_color()));
+    }
+
+    #[test]
+    fn test_adapt_ink_color() {
+        let close = |a: [f32; 4], b: [f32; 4]| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-5);
+        // Schwarz wird Weiß, Deckkraft bleibt
+        assert!(close(
+            adapt_ink_color([0.0, 0.0, 0.0, 0.7]),
+            [1.0, 1.0, 1.0, 0.7]
+        ));
+        // Notiz-Schwarz wird hell
+        let ink = adapt_ink_color([0.12, 0.12, 0.14, 1.0]);
+        assert!(ink[0] > 0.85 && ink[2] > 0.85);
+        // Dunkelblau wird Hellblau: Farbton bleibt (Blau bleibt der stärkste Kanal)
+        let blue = adapt_ink_color([0.0, 0.0, 0.5, 1.0]);
+        assert!(close(blue, [0.5, 0.5, 1.0, 1.0]));
+        // Helle und gesättigte Farben bleiben unverändert (Rot, Universitäts-Blau, Textmarker)
+        for c in [
+            [0.85, 0.20, 0.20, 1.0],
+            [0.15, 0.35, 0.85, 1.0],
+            [1.0, 0.95, 0.1, 0.35],
+            [1.0, 1.0, 1.0, 1.0],
+        ] {
+            assert!(close(adapt_ink_color(c), c), "{c:?} wurde verändert");
+        }
+        // Ergebnis ist nie heller als Weiß
+        for c in [[0.0, 0.3, 0.1, 1.0], [0.45, 0.45, 0.48, 1.0]] {
+            assert!(adapt_ink_color(c)[..3].iter().all(|&x| x <= 1.0 + 1e-6));
+        }
+    }
+
+    #[test]
+    fn test_paper_themes_contrast() {
+        for theme in PaperTheme::ALL {
+            let paper = theme.paper_color()[0];
+            let pattern = theme.pattern_color()[0];
+            assert!(
+                (paper - pattern).abs() > 0.03,
+                "{theme:?}: Muster hebt sich nicht vom Papier ab"
+            );
+            // Helles Papier ↔ dunkles Papier
+            assert_eq!(theme.is_dark(), paper < 0.5, "{theme:?}");
+        }
+    }
 }

src/bin/crash_sim.rs

@@ -0,0 +1,221 @@
+//! Crash-Simulationstesthelfer für ink-notes.
+//! Wird von scripts/crash-test.sh verwendet, um unvollständige Schreibvorgänge
+//! und SIGKILL (kill -9) Robustheit zu verifizieren.
+
+use std::env;
+use std::path::Path;
+use std::process;
+use std::time::Duration;
+
+use glam::Vec2;
+use ink_notes::document::{Notebook, PageBackground, StylusSample};
+use ink_notes::spline::{finalize_stroke_with_config, SplineConfig};
+use ink_notes::storage::{
+    cleanup_orphaned_temp_files, load_notebook, load_page, save_manifest, save_notebook, save_page,
+    NotebookManifest, PageData,
+};
+
+fn run_init(dir: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    let nb = Notebook::new();
+    let id = dir
+        .file_name()
+        .and_then(|n| n.to_str())
+        .unwrap_or("crash_test");
+    let mut m = NotebookManifest::new(id, "Crash Test Notebook");
+    m.sync_from_notebook(&nb);
+    save_notebook(dir, &nb, &mut m)?;
+    println!("[init] Initialized clean notebook in {:?}", dir);
+    Ok(())
+}
+
+fn run_worker(dir: &Path) {
+    let (mut notebook, mut manifest) = match load_notebook(dir) {
+        Ok((nb, m)) => (nb, m),
+        Err(_) => {
+            let nb = Notebook::new();
+            let id = dir
+                .file_name()
+                .and_then(|n| n.to_str())
+                .unwrap_or("crash_test");
+            let mut m = NotebookManifest::new(id, "Crash Test Notebook");
+            m.sync_from_notebook(&nb);
+            let _ = save_notebook(dir, &nb, &mut m);
+            (nb, m)
+        }
+    };
+
+    let spline_cfg = SplineConfig::default();
+    let mut stroke_counter = manifest.next_stroke_id;
+
+    println!("[worker] Started writing loop in {:?}", dir);
+
+    loop {
+        // Erzeuge neuen Strich mit einigen Samples
+        let base_x = (stroke_counter % 500) as f32;
+        let samples = vec![
+            StylusSample {
+                position: Vec2::new(base_x, 100.0),
+                pressure: 0.5,
+                timestamp: 0.0,
+            },
+            StylusSample {
+                position: Vec2::new(base_x + 10.0, 150.0),
+                pressure: 0.7,
+                timestamp: 0.01,
+            },
+            StylusSample {
+                position: Vec2::new(base_x + 20.0, 200.0),
+                pressure: 0.6,
+                timestamp: 0.02,
+            },
+        ];
+
+        let stroke = finalize_stroke_with_config(
+            stroke_counter,
+            &samples,
+            [0.0, 0.0, 0.0, 1.0],
+            &spline_cfg,
+        );
+        stroke_counter += 1;
+        manifest.next_stroke_id = stroke_counter;
+
+        let page = notebook.current_page_mut();
+        page.add_stroke(stroke);
+
+        let page_data = PageData::from(&*page);
+
+        // 1. Schreibe Seite atomar
+        if let Err(e) = save_page(dir, &page_data) {
+            eprintln!("[worker] Error saving page: {:?}", e);
+        }
+
+        // 2. Aktualisiere Manifest atomar
+        manifest.sync_from_notebook(&notebook);
+        if let Err(e) = save_manifest(dir, &manifest) {
+            eprintln!("[worker] Error saving manifest: {:?}", e);
+        }
+
+        // 3. Gelegentlich Gesamtsave (wie Autosave-Flush)
+        if stroke_counter % 5 == 0 {
+            if let Err(e) = save_notebook(dir, &notebook, &mut manifest) {
+                eprintln!("[worker] Error saving notebook: {:?}", e);
+            }
+        }
+
+        // 4. Evtl. neue Seite anlegen und sofort sichern, bevor Manifest aktualisiert wird
+        if stroke_counter % 25 == 0 {
+            let page_idx = notebook.add_page(PageBackground::DotGrid);
+            notebook.current_page_index = page_idx;
+            let new_page_data = PageData::from(notebook.current_page());
+            if let Err(e) = save_page(dir, &new_page_data) {
+                eprintln!("[worker] Error saving new page: {:?}", e);
+            }
+            manifest.sync_from_notebook(&notebook);
+            if let Err(e) = save_manifest(dir, &manifest) {
+                eprintln!("[worker] Error saving manifest: {:?}", e);
+            }
+        }
+    }
+}
+
+fn run_verify(dir: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    println!("[verify] Checking notebook in {:?}", dir);
+
+    // 1. Bereinige eventuelle verwaiste .tmp-Dateien
+    let _ = cleanup_orphaned_temp_files(dir, Duration::from_secs(0));
+
+    // Prüfe, ob das Verzeichnis noch gar kein Notizbuch enthält (Prozess vor erstem Flush getötet)
+    let manifest_path = dir.join("manifest.json");
+    let manifest_bak = dir.join("manifest.json.bak");
+    if !manifest_path.exists() && !manifest_bak.exists() {
+        println!("[verify] Notebook not yet created on disk (killed prior to first save). Valid empty state.");
+        return Ok(());
+    }
+
+    // 2. Notizbuch laden
+    let (_notebook, manifest) = match load_notebook(dir) {
+        Ok(res) => res,
+        Err(e) => {
+            eprintln!("[verify] FAILED to load notebook: {:?}", e);
+            return Err(Box::new(e));
+        }
+    };
+
+    println!(
+        "[verify] Manifest loaded successfully: title='{}', pages={}, next_stroke_id={}",
+        manifest.title,
+        manifest.pages.len(),
+        manifest.next_stroke_id
+    );
+
+    // 3. Alle im Manifest registrierten Seiten laden und prüfen
+    for page_meta in &manifest.pages {
+        match load_page(dir, page_meta.id) {
+            Ok(page_data) => {
+                let page = page_data.to_page();
+                println!(
+                    "[verify] Page {} verified: {} strokes, background={:?}",
+                    page_meta.id,
+                    page.strokes.len(),
+                    page.background
+                );
+            }
+            Err(e) => {
+                eprintln!(
+                    "[verify] FAILED to load page {} referenced by manifest: {:?}",
+                    page_meta.id, e
+                );
+                return Err(Box::new(e));
+            }
+        }
+    }
+
+    // 4. Prüfen ob Quarantäne-Dateien existieren
+    if let Ok(entries) = std::fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            let file_name = entry.file_name();
+            let name = file_name.to_string_lossy();
+            if name.contains(".corrupt-") {
+                println!("[verify] Notice: Found quarantined file: {}", name);
+            }
+        }
+    }
+
+    println!("[verify] SUCCESS: All pages and manifest are fully consistent!");
+    Ok(())
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    if args.len() < 3 {
+        eprintln!("Usage: crash_sim <init|worker|verify> <notebook_dir>");
+        process::exit(2);
+    }
+
+    let command = &args[1];
+    let notebook_dir = Path::new(&args[2]);
+
+    match command.as_str() {
+        "init" => match run_init(notebook_dir) {
+            Ok(_) => process::exit(0),
+            Err(e) => {
+                eprintln!("[init] Error: {}", e);
+                process::exit(1);
+            }
+        },
+        "worker" => {
+            run_worker(notebook_dir);
+        }
+        "verify" => match run_verify(notebook_dir) {
+            Ok(_) => process::exit(0),
+            Err(e) => {
+                eprintln!("[verify] Error: {}", e);
+                process::exit(1);
+            }
+        },
+        other => {
+            eprintln!("Unknown command: {}", other);
+            process::exit(2);
+        }
+    }
+}

src/canvas.rs

@@ -11,9 +11,7 @@ use std::sync::Arc;
 use winit::dpi::PhysicalSize;
 use winit::window::Window;
 
-use crate::background::{
-    generate_background_mesh, generate_paper_quad, DESK_COLOR,
-};
+use crate::background::{generate_background_mesh, generate_paper_quad, PaperTheme};
 use crate::document::{Page, PageBackground, PageViewport, Stroke, StylusSample};
 use crate::filter::OneEuroFilter;
 use crate::spline::{self, ControlPoint, SplineConfig};
@@ -60,6 +58,8 @@ impl InkVertex {
 pub struct CameraUniforms {
     pub transform_scale: [f32; 2],
     pub transform_offset: [f32; 2],
+    /// x: 1.0 = dunkle Tinte aufhellen (Shader `fs_ink`), y–w: ungenutzt (Ausrichtung)
+    pub ink_params: [f32; 4],
 }
 
 /// Transformiert einen Pixel-Koordinatenpunkt in den Normalized Device Coordinate (NDC) Raum [-1.0, 1.0].
@@ -89,13 +89,43 @@ pub fn spline_vertices_to_ndc(
 }
 
 /// Verwaltet den GPU-Zustand, Surface, Pipelines und Buffer für das Inking.
+/// Meldung, wenn kein Grafikadapter das Fenster darstellen kann.
+pub const NO_USABLE_GPU_MESSAGE: &str = "Keine nutzbare Grafikschnittstelle gefunden.\n\
+     Häufigste Ursache: Der Benutzer darf nicht auf die Grafikkarte zugreifen (/dev/dri).\n\
+     Prüfen mit `ls -l /dev/dri` und `groups`; ggf. `sudo usermod -aG render,video $USER`\n\
+     und neu anmelden. Alternativ einen Software-Renderer installieren (Paket mesa-vulkan-drivers)\n\
+     oder die Schnittstelle festlegen, z. B. `WGPU_BACKEND=vulkan ink-notes`.";
+
+/// Wählt den Darstellungsmodus: Mailbox (geringste Latenz), sonst Fifo, sonst den ersten
+/// angebotenen. `None`, wenn keiner angeboten wird. `INK_FORCE_FIFO` erzwingt Fifo.
+pub fn choose_present_mode(available: &[wgpu::PresentMode]) -> Option<wgpu::PresentMode> {
+    let force_fifo = std::env::var("INK_FORCE_FIFO").is_ok();
+    let preferred: &[wgpu::PresentMode] = if force_fifo {
+        &[wgpu::PresentMode::Fifo]
+    } else {
+        &[wgpu::PresentMode::Mailbox, wgpu::PresentMode::Fifo]
+    };
+    preferred
+        .iter()
+        .copied()
+        .find(|m| available.contains(m))
+        .or_else(|| available.first().copied())
+}
+
 pub struct CanvasState {
     pub surface: wgpu::Surface<'static>,
+    /// Verwendeter Grafikadapter (für erneute Abfrage der Surface-Fähigkeiten bei Größenänderung)
+    adapter: wgpu::Adapter,
+    /// Meldung „keine Darstellungsmodi“ wurde bereits ausgegeben
+    presentation_warned: bool,
     pub device: wgpu::Device,
     pub queue: wgpu::Queue,
     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
@@ -106,6 +136,7 @@ pub struct CanvasState {
     pub camera_buffer: wgpu::Buffer,
     pub camera_bind_group: wgpu::BindGroup,
     pub current_ink_color: [f32; 4],
+    pub current_stroke_width_mm: f32,
 
     // Statische Hintergrund-Geometrie
     pub paper_buffer: wgpu::Buffer,
@@ -113,6 +144,10 @@ pub struct CanvasState {
     pub background_vertex_capacity: usize,
     pub background_vertex_count: u32,
     pub current_background: PageBackground,
+    /// Papierfarbe der Anzeige
+    pub paper_theme: PaperTheme,
+    /// Dunkle Tinte auf dunklem Papier aufhellen
+    pub adapt_ink: bool,
 
     // Pipeline-Trennung: Live-Strich (aktiver Stroke)
     pub live_vertex_buffer: wgpu::Buffer,
@@ -130,6 +165,9 @@ pub struct CanvasState {
     pub committed_vertex_count: u32,
     pub committed_strokes: Vec<Range<u32>>,
 
+    // Eingefügte Bilder der aktuellen Seite
+    image_layer: crate::image_layer::ImageLayer,
+
     // egui UI-Renderer
     pub egui_renderer: egui_wgpu::Renderer,
 }
@@ -143,25 +181,50 @@ impl CanvasState {
     /// Initialisiert den CanvasState für das übergebene Winit-Fenster.
     pub async fn new(window: Arc<Window>) -> Result<Self, Box<dyn std::error::Error>> {
         let size = window.inner_size();
-        let viewport = PageViewport::calculate(size.width as f32, size.height as f32, Self::VIEWPORT_MARGIN);
+        let viewport =
+            PageViewport::calculate(size.width as f32, size.height as f32, Self::VIEWPORT_MARGIN);
 
-        // 1. WGPU Instance & Surface
+        // 1. WGPU Instance & Surface (Grafikschnittstelle per WGPU_BACKEND wählbar, z. B. "vulkan")
         let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
-            backends: wgpu::Backends::all(),
+            backends: wgpu::util::backend_bits_from_env().unwrap_or(wgpu::Backends::all()),
             ..Default::default()
         });
 
         let surface = instance.create_surface(window.clone())?;
 
-        // 2. Adapter auswählen (hohe Performance bevorzugt)
-        let adapter = instance
-            .request_adapter(&wgpu::RequestAdapterOptions {
-                power_preference: wgpu::PowerPreference::HighPerformance,
-                compatible_surface: Some(&surface),
-                force_fallback_adapter: false,
-            })
-            .await
-            .ok_or("Kein passender GPU-Adapter gefunden")?;
+        // 2. Adapter auswählen: zuerst die GPU, dann der Software-Renderer (z. B. lavapipe).
+        //    Ein Adapter taugt nur, wenn er für dieses Fenster Formate und Darstellungsmodi
+        //    anbietet – fehlt z. B. der Zugriff auf /dev/dri, ist die Liste leer.
+        let mut chosen = None;
+        for force_fallback_adapter in [false, true] {
+            let Some(adapter) = instance
+                .request_adapter(&wgpu::RequestAdapterOptions {
+                    power_preference: wgpu::PowerPreference::HighPerformance,
+                    compatible_surface: Some(&surface),
+                    force_fallback_adapter,
+                })
+                .await
+            else {
+                continue;
+            };
+            let info = adapter.get_info();
+            let caps = surface.get_capabilities(&adapter);
+            match choose_present_mode(&caps.present_modes) {
+                Some(mode) if !caps.formats.is_empty() && !caps.alpha_modes.is_empty() => {
+                    eprintln!(
+                        "[Grafik] Adapter: {} ({:?}), Darstellungsmodus {:?}",
+                        info.name, info.backend, mode
+                    );
+                    chosen = Some((adapter, caps, mode));
+                    break;
+                }
+                _ => eprintln!(
+                    "[Grafik] Adapter {} ({:?}) bietet für das Fenster keine Darstellung an, versuche den nächsten.",
+                    info.name, info.backend
+                ),
+            }
+        }
+        let (adapter, surface_caps, present_mode) = chosen.ok_or(NO_USABLE_GPU_MESSAGE)?;
 
         // 3. Device & Queue erstellen
         let (device, queue) = adapter
@@ -175,8 +238,7 @@ impl CanvasState {
             )
             .await?;
 
-        // 4. Zero-Latency-Pufferung: Mailbox mit Fallback Fifo & Frame-Latency 1
-        let surface_caps = surface.get_capabilities(&adapter);
+        // 4. Zero-Latency-Pufferung (Mailbox, sonst Fifo) & Frame-Latency 1
         let surface_format = surface_caps
             .formats
             .iter()
@@ -184,17 +246,6 @@ impl CanvasState {
             .find(|f| f.is_srgb())
             .unwrap_or(surface_caps.formats[0]);
 
-        let present_mode = if std::env::var("INK_FORCE_FIFO").is_ok() {
-            eprintln!("Erzwinge PresentMode::Fifo (via INK_FORCE_FIFO)");
-            wgpu::PresentMode::Fifo
-        } else if surface_caps.present_modes.contains(&wgpu::PresentMode::Mailbox) {
-            eprintln!("Verwende Zero-Latency PresentMode::Mailbox");
-            wgpu::PresentMode::Mailbox
-        } else {
-            eprintln!("Mailbox nicht verfügbar, Fallback auf PresentMode::Fifo");
-            wgpu::PresentMode::Fifo
-        };
-
         let config = wgpu::SurfaceConfiguration {
             usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
             format: surface_format,
@@ -233,6 +284,7 @@ impl CanvasState {
         let camera_uniforms = CameraUniforms {
             transform_scale: scale,
             transform_offset: offset,
+            ink_params: [0.0; 4],
         };
         let camera_buffer = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Camera Uniform Buffer"),
@@ -269,7 +321,7 @@ impl CanvasState {
             },
             fragment: Some(wgpu::FragmentState {
                 module: &shader,
-                entry_point: "fs_main",
+                entry_point: "fs_ink",
                 targets: &[Some(wgpu::ColorTargetState {
                     format: config.format,
                     blend: Some(wgpu::BlendState::ALPHA_BLENDING),
@@ -323,7 +375,8 @@ impl CanvasState {
         });
 
         // 6. Statische Buffer
-        let paper_quad = generate_paper_quad();
+        let paper_theme = PaperTheme::default();
+        let paper_quad = generate_paper_quad(paper_theme.paper_color());
         let paper_buffer = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Paper Quad Buffer"),
             size: (paper_quad.len() * std::mem::size_of::<InkVertex>()) as u64,
@@ -333,7 +386,7 @@ impl CanvasState {
         queue.write_buffer(&paper_buffer, 0, bytemuck::cast_slice(&paper_quad));
 
         let current_background = PageBackground::Grid5mm;
-        let bg_mesh = generate_background_mesh(current_background);
+        let bg_mesh = generate_background_mesh(current_background, paper_theme.pattern_color());
         let background_buffer = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Background Mesh Buffer"),
             size: (Self::INITIAL_BACKGROUND_CAPACITY * std::mem::size_of::<InkVertex>()) as u64,
@@ -357,31 +410,40 @@ impl CanvasState {
             mapped_at_creation: false,
         });
 
-        // 8. egui Renderer für das schwebende UI initialisieren
-        let egui_renderer = egui_wgpu::Renderer::new(
+        let image_layer = crate::image_layer::ImageLayer::new(
             &device,
+            &shader,
+            &bind_group_layout,
             config.format,
-            None,
-            1,
         );
 
+        // 8. egui Renderer für das schwebende UI initialisieren
+        let egui_renderer = egui_wgpu::Renderer::new(&device, config.format, None, 1);
+
         Ok(Self {
             surface,
+            adapter,
+            presentation_warned: false,
             device,
             queue,
             config,
             size,
             viewport,
+            ui_inset_left: 0.0,
+            ui_inset_right: 0.0,
             strip_pipeline,
             triangle_pipeline,
             camera_buffer,
             camera_bind_group,
             current_ink_color: default_ink_color,
+            current_stroke_width_mm: 0.5,
             paper_buffer,
             background_buffer,
             background_vertex_capacity: Self::INITIAL_BACKGROUND_CAPACITY,
             background_vertex_count: bg_mesh.len() as u32,
             current_background,
+            paper_theme,
+            adapt_ink: false,
             live_vertex_buffer,
             live_vertex_capacity: Self::INITIAL_LIVE_CAPACITY,
             live_vertex_count: 0,
@@ -398,6 +460,7 @@ impl CanvasState {
             committed_vertex_capacity: Self::INITIAL_COMMITTED_CAPACITY,
             committed_vertex_count: 0,
             committed_strokes: Vec::with_capacity(128),
+            image_layer,
             egui_renderer,
             camera: crate::viewport::ViewportState::new(),
         })
@@ -409,8 +472,45 @@ impl CanvasState {
         let camera_uniforms = CameraUniforms {
             transform_scale: scale,
             transform_offset: offset,
+            ink_params: [
+                if self.adapt_ink && self.paper_theme.is_dark() {
+                    1.0
+                } else {
+                    0.0
+                },
+                0.0,
+                0.0,
+                0.0,
+            ],
         };
-        self.queue.write_buffer(&self.camera_buffer, 0, bytemuck::cast_slice(&[camera_uniforms]));
+        self.queue.write_buffer(
+            &self.camera_buffer,
+            0,
+            bytemuck::cast_slice(&[camera_uniforms]),
+        );
+    }
+
+    /// 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.
@@ -419,27 +519,39 @@ impl CanvasState {
             self.size = new_size;
             self.config.width = new_size.width;
             self.config.height = new_size.height;
+            // Fähigkeiten neu abfragen: Ein nicht (mehr) angebotener Modus führt in wgpu zum Absturz
+            let caps = self.surface.get_capabilities(&self.adapter);
+            if !caps.present_modes.contains(&self.config.present_mode) {
+                match choose_present_mode(&caps.present_modes) {
+                    Some(mode) => self.config.present_mode = mode,
+                    None => {
+                        if !self.presentation_warned {
+                            eprintln!(
+                                "[Grafik] Fenster kann derzeit nicht dargestellt werden (keine Darstellungsmodi). {}",
+                                NO_USABLE_GPU_MESSAGE
+                            );
+                            self.presentation_warned = true;
+                        }
+                        return;
+                    }
+                }
+            }
             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();
         }
     }
 
     /// Verschiebt den Bildausschnitt um Bildschirm-Pixel delta.
     pub fn pan(&mut self, delta_x: f32, delta_y: f32) {
-        self.camera.pan_by_screen_delta(delta_x, delta_y, &self.viewport);
+        self.camera
+            .pan_by_screen_delta(delta_x, delta_y, &self.viewport);
         self.update_uniforms();
     }
 
     /// Zoomt zentriert auf eine Cursor-Bildschirmposition.
     pub fn zoom_at(&mut self, cursor_x: f32, cursor_y: f32, factor: f32) {
-        self.camera.zoom_at_cursor([cursor_x, cursor_y], factor, &self.viewport);
+        self.camera
+            .zoom_at_cursor([cursor_x, cursor_y], factor, &self.viewport);
         self.update_uniforms();
     }
 
@@ -451,12 +563,14 @@ impl CanvasState {
 
     /// Transformiert Fenster-Pixel in Seitenkoordinaten.
     pub fn screen_to_page(&self, screen_x: f32, screen_y: f32) -> Option<glam::Vec2> {
-        self.camera.screen_to_page(screen_x, screen_y, &self.viewport)
+        self.camera
+            .screen_to_page(screen_x, screen_y, &self.viewport)
     }
 
     /// Transformiert Fenster-Pixel in Seitenkoordinaten und klemmt auf die Seite.
     pub fn screen_to_page_clamped(&self, screen_x: f32, screen_y: f32) -> glam::Vec2 {
-        self.camera.screen_to_page_clamped(screen_x, screen_y, &self.viewport)
+        self.camera
+            .screen_to_page_clamped(screen_x, screen_y, &self.viewport)
     }
 
     /// Transformiert einen Punkt aus DIN-A4-Seitenkoordinaten in Fenster-Bildschirmkoordinaten.
@@ -471,7 +585,8 @@ impl CanvasState {
         self.live_vertex_count = self.live_vertices.len() as u32;
 
         if self.live_vertices.len() > self.live_vertex_capacity {
-            self.live_vertex_capacity = (self.live_vertices.len() * 2).max(Self::INITIAL_LIVE_CAPACITY);
+            self.live_vertex_capacity =
+                (self.live_vertices.len() * 2).max(Self::INITIAL_LIVE_CAPACITY);
             self.live_vertex_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
                 label: Some("Live Stroke Vertex Buffer (Reallocated)"),
                 size: (self.live_vertex_capacity * std::mem::size_of::<InkVertex>()) as u64,
@@ -496,10 +611,24 @@ impl CanvasState {
 
     /// Konfiguriert die Strichbreite in Millimetern.
     pub fn set_stroke_width_mm(&mut self, width_mm: f32) {
-        // 10 Einheiten = 1 mm. Radius = (width_mm * 10.0) / 2.0 = width_mm * 5.0.
-        let base_radius = (width_mm * 5.0).max(0.25);
-        self.spline_config.min_radius = (base_radius * 0.5).max(0.15);
-        self.spline_config.max_radius = (base_radius * 1.5).max(0.35);
+        self.current_stroke_width_mm = width_mm;
+        self.spline_config =
+            SplineConfig::from_width_units(width_mm * crate::document::UNITS_PER_MM);
+    }
+
+    /// Setzt die Papierfarbe und ob dunkle Tinte auf dunklem Papier aufgehellt wird.
+    pub fn set_paper_theme(&mut self, theme: PaperTheme, adapt_ink: bool) {
+        self.adapt_ink = adapt_ink;
+        if self.paper_theme != theme {
+            self.paper_theme = theme;
+            self.queue.write_buffer(
+                &self.paper_buffer,
+                0,
+                bytemuck::cast_slice(&generate_paper_quad(theme.paper_color())),
+            );
+            self.upload_background_mesh();
+        }
+        self.update_uniforms();
     }
 
     /// Setzt den Seitenhintergrund und aktualisiert bei Bedarf den Vertex-Puffer.
@@ -508,7 +637,13 @@ impl CanvasState {
             return;
         }
         self.current_background = background;
-        let mesh = generate_background_mesh(background);
+        self.upload_background_mesh();
+    }
+
+    /// Erzeugt das Muster für Hintergrund und Papierfarbe neu und lädt es auf die GPU.
+    fn upload_background_mesh(&mut self) {
+        let mesh =
+            generate_background_mesh(self.current_background, self.paper_theme.pattern_color());
         self.background_vertex_count = mesh.len() as u32;
 
         if mesh.len() > self.background_vertex_capacity {
@@ -522,7 +657,8 @@ impl CanvasState {
         }
 
         if !mesh.is_empty() {
-            self.queue.write_buffer(&self.background_buffer, 0, bytemuck::cast_slice(&mesh));
+            self.queue
+                .write_buffer(&self.background_buffer, 0, bytemuck::cast_slice(&mesh));
         }
     }
 
@@ -530,6 +666,18 @@ impl CanvasState {
     pub fn sync_page(&mut self, page: &mut Page) {
         page.rebuild_cache_if_dirty();
         self.set_background(page.background);
+        // PDF-Seite zuerst, darüber die eingefügten Bilder
+        self.image_layer.set_quads(
+            page.pdf_background
+                .iter()
+                .map(|pdf| (pdf.key(), pdf.corners()))
+                .chain(
+                    page.strokes
+                        .iter()
+                        .filter_map(|s| Some((s.image.clone()?, s.image_corners()?))),
+                )
+                .collect(),
+        );
 
         self.committed_vertex_count = page.vertex_cache.len() as u32;
         self.committed_strokes = page.stroke_ranges.clone();
@@ -539,7 +687,8 @@ impl CanvasState {
         }
 
         if page.vertex_cache.len() > self.committed_vertex_capacity {
-            self.committed_vertex_capacity = (page.vertex_cache.len() * 2).max(Self::INITIAL_COMMITTED_CAPACITY);
+            self.committed_vertex_capacity =
+                (page.vertex_cache.len() * 2).max(Self::INITIAL_COMMITTED_CAPACITY);
             self.committed_vertex_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
                 label: Some("Committed Strokes Vertex Buffer (Reallocated)"),
                 size: (self.committed_vertex_capacity * std::mem::size_of::<InkVertex>()) as u64,
@@ -555,6 +704,20 @@ impl CanvasState {
         );
     }
 
+    /// Lädt Bilder und PDF-Seiten der aktuellen Seite, die noch nicht auf der GPU liegen.
+    /// Vor jedem Zeichnen aufrufen; ohne Änderungen kostet das fast nichts.
+    pub fn prepare_images(
+        &mut self,
+        load: &mut dyn FnMut(&str) -> crate::image_layer::TextureSource,
+    ) {
+        self.image_layer.prepare(&self.device, &self.queue, load);
+    }
+
+    /// Wird noch eine PDF-Seite im Hintergrund gerendert?
+    pub fn is_waiting_for_images(&self) -> bool {
+        self.image_layer.is_waiting()
+    }
+
     /// Startet einen neuen Live-Strich in DIN-A4-Seitenkoordinaten.
     pub fn start_stroke(&mut self, page_x: f32, page_y: f32, pressure: f32, timestamp: f64) {
         self.filter.reset();
@@ -635,6 +798,9 @@ impl CanvasState {
             self.current_ink_color,
             &self.spline_config,
         );
+        let mut stroke = stroke;
+        stroke.width = self.current_stroke_width_mm * crate::document::UNITS_PER_MM;
+        stroke.finalized = true;
 
         // Temporären GPU-Live-Buffer vollständig leeren
         self.live_samples.clear();
@@ -655,7 +821,8 @@ impl CanvasState {
         }
 
         let color = self.current_ink_color;
-        let raw_strip = spline::generate_triangle_strip(&self.live_control_points, &self.spline_config);
+        let raw_strip =
+            spline::generate_triangle_strip(&self.live_control_points, &self.spline_config);
         self.live_vertices = raw_strip
             .into_iter()
             .map(|v| InkVertex::new(v.position[0], v.position[1], color))
@@ -667,7 +834,8 @@ impl CanvasState {
         }
 
         if self.live_vertices.len() > self.live_vertex_capacity {
-            self.live_vertex_capacity = (self.live_vertices.len() * 2).max(Self::INITIAL_LIVE_CAPACITY);
+            self.live_vertex_capacity =
+                (self.live_vertices.len() * 2).max(Self::INITIAL_LIVE_CAPACITY);
             self.live_vertex_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
                 label: Some("Live Stroke Vertex Buffer (Reallocated)"),
                 size: (self.live_vertex_capacity * std::mem::size_of::<InkVertex>()) as u64,
@@ -694,7 +862,8 @@ impl CanvasState {
     ) -> Result<(), wgpu::SurfaceError> {
         // Vor dem Renderpass: egui-Texturen aktualisieren
         for (id, image_delta) in &textures_delta.set {
-            self.egui_renderer.update_texture(&self.device, &self.queue, *id, image_delta);
+            self.egui_renderer
+                .update_texture(&self.device, &self.queue, *id, image_delta);
         }
 
         let output = self.surface.get_current_texture()?;
@@ -725,7 +894,7 @@ impl CanvasState {
                     view: &view,
                     resolve_target: None,
                     ops: wgpu::Operations {
-                        load: wgpu::LoadOp::Clear(DESK_COLOR), // Dunkler Tischhintergrund
+                        load: wgpu::LoadOp::Clear(self.paper_theme.desk_color()), // Tischhintergrund
                         store: wgpu::StoreOp::Store,
                     },
                 })],
@@ -737,7 +906,7 @@ impl CanvasState {
             // 2D-Kamera Uniforms (Scale & Offset) binden
             render_pass.set_bind_group(0, &self.camera_bind_group, &[]);
 
-            // 1. Weißes DIN-A4-Blatt zeichnen (Farbe ist direkt im Paper-Quad Vertex hinterlegt)
+            // 1. DIN-A4-Blatt in Papierfarbe zeichnen (Farbe ist direkt im Paper-Quad Vertex hinterlegt)
             render_pass.set_pipeline(&self.triangle_pipeline);
             render_pass.set_vertex_buffer(0, self.paper_buffer.slice(..));
             render_pass.draw(0..6, 0..1);
@@ -748,7 +917,10 @@ impl CanvasState {
                 render_pass.draw(0..self.background_vertex_count, 0..1);
             }
 
-            // 3. Abgeschlossene Striche der aktiven Seite rendern (TriangleStrip mit Vertex-Farben)
+            // 3. Eingefügte Bilder (unter der Tinte)
+            self.image_layer.draw(&mut render_pass);
+
+            // 4. Abgeschlossene Striche der aktiven Seite rendern (TriangleStrip mit Vertex-Farben)
             render_pass.set_pipeline(&self.strip_pipeline);
 
             if self.committed_vertex_count > 0 {
@@ -760,7 +932,7 @@ impl CanvasState {
                 }
             }
 
-            // 4. Temporäre Live-Geometrie des aktuellen Strichs rendern (Zero Latency)
+            // 5. Temporäre Live-Geometrie des aktuellen Strichs rendern (Zero Latency)
             if self.live_vertex_count > 0 {
                 render_pass.set_vertex_buffer(0, self.live_vertex_buffer.slice(..));
                 render_pass.draw(0..self.live_vertex_count, 0..1);
@@ -784,7 +956,8 @@ impl CanvasState {
                 occlusion_query_set: None,
             });
 
-            self.egui_renderer.render(&mut egui_pass, clipped_primitives, screen_descriptor);
+            self.egui_renderer
+                .render(&mut egui_pass, clipped_primitives, screen_descriptor);
         }
 
         self.queue.submit(std::iter::once(encoder.finish()));
@@ -813,6 +986,16 @@ impl CanvasState {
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_choose_present_mode() {
+        use wgpu::PresentMode::{Fifo, Immediate, Mailbox};
+        assert_eq!(choose_present_mode(&[Fifo, Mailbox]), Some(Mailbox));
+        assert_eq!(choose_present_mode(&[Fifo, Immediate]), Some(Fifo));
+        assert_eq!(choose_present_mode(&[Immediate]), Some(Immediate));
+        // Keine Darstellungsmodi (z. B. kein Zugriff auf /dev/dri): kein Absturz, sondern None
+        assert_eq!(choose_present_mode(&[]), None);
+    }
+
     #[test]
     fn test_pixel_to_ndc_mapping() {
         let width = 800.0;
@@ -838,7 +1021,40 @@ mod tests {
     #[test]
     fn test_camera_uniforms() {
         let _u = CameraUniforms::default();
-        assert_eq!(std::mem::size_of::<CameraUniforms>(), 16);
+        // Muss dem WGSL-Layout entsprechen: vec2 + vec2 + vec4
+        assert_eq!(std::mem::size_of::<CameraUniforms>(), 32);
+    }
+
+    #[test]
+    fn test_shader_is_valid_and_matches_uniforms() {
+        // Ein Shaderfehler fiele sonst erst beim Programmstart auf
+        let module = naga::front::wgsl::parse_str(include_str!("shader.wgsl"))
+            .unwrap_or_else(|e| panic!("WGSL-Fehler: {e}"));
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::empty(),
+        )
+        .validate(&module)
+        .unwrap_or_else(|e| panic!("Shader ungültig: {e:?}"));
+
+        for name in ["vs_main", "fs_main", "fs_ink", "vs_image", "fs_image"] {
+            assert!(
+                module.entry_points.iter().any(|ep| ep.name == name),
+                "Einstiegspunkt {name} fehlt"
+            );
+        }
+        let camera = module
+            .types
+            .iter()
+            .find(|(_, ty)| ty.name.as_deref() == Some("CameraUniforms"))
+            .expect("CameraUniforms fehlt im Shader")
+            .1;
+        match camera.inner {
+            naga::TypeInner::Struct { span, .. } => {
+                assert_eq!(span as usize, std::mem::size_of::<CameraUniforms>())
+            }
+            ref other => panic!("CameraUniforms ist kein Struct: {other:?}"),
+        }
     }
 
     #[test]

src/file_picker.rs

@@ -0,0 +1,248 @@
+//! Eingebaute, stift- und fingertaugliche Dateiauswahl für Bilder und PDFs.
+//!
+//! Bewusst ohne Systemdialog: der bräuchte GTK oder das Desktop-Portal, die unter WSL und auf
+//! schlanken Systemen oft fehlen. Die Auswahl zeigt Ordner und die passenden Dateien des
+//! aktuellen Ordners; versteckte Dateien bleiben ausgeblendet.
+
+use std::path::{Path, PathBuf};
+
+use crate::assets::is_supported_image_path;
+
+/// Ein Eintrag der Dateiliste.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PickerEntry {
+    pub name: String,
+    pub path: PathBuf,
+    pub is_dir: bool,
+}
+
+/// Welche Dateien die Auswahl anbietet.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PickerKind {
+    /// Bilder zum Einfügen auf der aktuellen Seite
+    Image,
+    /// PDF zum Importieren als neues Notizbuch
+    Pdf,
+}
+
+impl PickerKind {
+    /// Passt die Datei zu dieser Auswahl?
+    pub fn accepts(self, path: &Path) -> bool {
+        match self {
+            PickerKind::Image => is_supported_image_path(path),
+            PickerKind::Pdf => is_pdf_path(path),
+        }
+    }
+}
+
+/// Ist die Datei dem Namen nach ein PDF?
+pub fn is_pdf_path(path: &Path) -> bool {
+    path.extension()
+        .and_then(|e| e.to_str())
+        .is_some_and(|e| e.eq_ignore_ascii_case("pdf"))
+}
+
+/// Zustand der Dateiauswahl.
+#[derive(Debug, Clone, PartialEq)]
+pub struct FilePicker {
+    pub kind: PickerKind,
+    pub dir: PathBuf,
+    pub entries: Vec<PickerEntry>,
+    /// Ordner nicht lesbar
+    pub error: Option<String>,
+}
+
+impl FilePicker {
+    /// Öffnet die Auswahl in `dir`, sonst im Bilder-Ordner (Bilder) bzw. Downloads (PDF),
+    /// sonst im Home-Ordner.
+    pub fn open(kind: PickerKind, dir: Option<&Path>) -> Self {
+        let start = dir
+            .filter(|d| d.is_dir())
+            .map(Path::to_path_buf)
+            .or_else(|| {
+                let preferred = match kind {
+                    PickerKind::Image => "🖼 Bilder",
+                    PickerKind::Pdf => "⬇ Downloads",
+                };
+                let all = shortcuts();
+                all.iter()
+                    .find(|(label, _)| *label == preferred)
+                    .or_else(|| all.last())
+                    .map(|(_, p)| p.clone())
+            })
+            .unwrap_or_else(|| PathBuf::from("/"));
+        let mut picker = Self {
+            kind,
+            dir: start.clone(),
+            entries: Vec::new(),
+            error: None,
+        };
+        picker.navigate(&start);
+        picker
+    }
+
+    /// Wechselt in `dir` und liest den Inhalt neu ein.
+    pub fn navigate(&mut self, dir: &Path) {
+        match list_dir(dir, self.kind) {
+            Ok(entries) => {
+                self.dir = dir.to_path_buf();
+                self.entries = entries;
+                self.error = None;
+            }
+            Err(err) => {
+                self.error = Some(format!(
+                    "'{}' kann nicht geöffnet werden: {err}",
+                    dir.display()
+                ));
+            }
+        }
+    }
+
+    /// Eine Ebene nach oben.
+    pub fn go_up(&mut self) {
+        if let Some(parent) = self.dir.parent().map(Path::to_path_buf) {
+            self.navigate(&parent);
+        }
+    }
+}
+
+/// Ordner und passende Dateien in `dir`: erst Ordner, dann Dateien, jeweils alphabetisch
+/// ohne Groß-/Kleinschreibung; versteckte Einträge (Punkt am Anfang) fehlen.
+pub fn list_dir(dir: &Path, kind: PickerKind) -> std::io::Result<Vec<PickerEntry>> {
+    let mut entries: Vec<PickerEntry> = std::fs::read_dir(dir)?
+        .filter_map(Result::ok)
+        .filter_map(|entry| {
+            let name = entry.file_name().to_string_lossy().into_owned();
+            if name.starts_with('.') {
+                return None;
+            }
+            let path = entry.path();
+            // Symlinks auflösen: ein Link auf einen Ordner ist ein Ordner
+            let is_dir = path.is_dir();
+            (is_dir || kind.accepts(&path)).then_some(PickerEntry { name, path, is_dir })
+        })
+        .collect();
+    entries.sort_by(|a, b| {
+        b.is_dir
+            .cmp(&a.is_dir)
+            .then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
+    });
+    Ok(entries)
+}
+
+/// Schnellzugriffe: Bilder, Downloads, Schreibtisch und Home-Ordner (soweit vorhanden),
+/// mit den Namen aus `~/.config/user-dirs.dirs` (z. B. „Bilder“ statt „Pictures“).
+pub fn shortcuts() -> Vec<(&'static str, PathBuf)> {
+    let Some(home) = std::env::var_os("HOME").map(PathBuf::from) else {
+        return Vec::new();
+    };
+    let user_dirs =
+        std::fs::read_to_string(home.join(".config/user-dirs.dirs")).unwrap_or_default();
+    let xdg = |key: &str, fallbacks: &[&str]| -> Option<PathBuf> {
+        parse_user_dir(&user_dirs, key, &home)
+            .into_iter()
+            .chain(fallbacks.iter().map(|f| home.join(f)))
+            .find(|p| p.is_dir() && *p != home)
+    };
+    let mut list = Vec::new();
+    if let Some(p) = xdg("XDG_PICTURES_DIR", &["Bilder", "Pictures"]) {
+        list.push(("🖼 Bilder", p));
+    }
+    if let Some(p) = xdg("XDG_DOWNLOAD_DIR", &["Downloads"]) {
+        list.push(("⬇ Downloads", p));
+    }
+    if let Some(p) = xdg("XDG_DESKTOP_DIR", &["Schreibtisch", "Desktop"]) {
+        list.push(("🖥 Schreibtisch", p));
+    }
+    list.push(("🏠 Persönlicher Ordner", home));
+    list
+}
+
+/// Liest einen Eintrag wie `XDG_PICTURES_DIR="$HOME/Bilder"` aus `user-dirs.dirs`.
+pub fn parse_user_dir(content: &str, key: &str, home: &Path) -> Option<PathBuf> {
+    content.lines().find_map(|line| {
+        let value = line
+            .trim()
+            .strip_prefix(key)?
+            .trim_start()
+            .strip_prefix('=')?;
+        let value = value.trim().trim_matches('"');
+        let path = match value.strip_prefix("$HOME") {
+            Some(rest) => home.join(rest.trim_start_matches('/')),
+            None => PathBuf::from(value),
+        };
+        path.is_absolute().then_some(path)
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_list_dir_sorts_and_filters() {
+        let dir = tempfile::tempdir().unwrap();
+        for name in [
+            "b.png",
+            "A.jpg",
+            "notiz.txt",
+            ".versteckt.png",
+            "c.webp",
+            "Skript.PDF",
+        ] {
+            std::fs::write(dir.path().join(name), b"x").unwrap();
+        }
+        std::fs::create_dir(dir.path().join("zOrdner")).unwrap();
+        std::fs::create_dir(dir.path().join("aOrdner")).unwrap();
+        std::fs::create_dir(dir.path().join(".cache")).unwrap();
+
+        let names = |kind| -> Vec<String> {
+            list_dir(dir.path(), kind)
+                .unwrap()
+                .into_iter()
+                .map(|e| e.name)
+                .collect()
+        };
+        assert_eq!(
+            names(PickerKind::Image),
+            ["aOrdner", "zOrdner", "A.jpg", "b.png", "c.webp"]
+        );
+        assert_eq!(names(PickerKind::Pdf), ["aOrdner", "zOrdner", "Skript.PDF"]);
+    }
+
+    #[test]
+    fn test_navigation_and_errors() {
+        let dir = tempfile::tempdir().unwrap();
+        let sub = dir.path().join("Fotos");
+        std::fs::create_dir(&sub).unwrap();
+        std::fs::write(sub.join("tafel.jpg"), b"x").unwrap();
+
+        let mut picker = FilePicker::open(PickerKind::Image, Some(&sub));
+        assert_eq!(picker.dir, sub);
+        assert_eq!(picker.entries.len(), 1);
+
+        picker.go_up();
+        assert_eq!(picker.dir, dir.path());
+        assert!(picker.entries.iter().any(|e| e.is_dir && e.name == "Fotos"));
+
+        // Nicht vorhandener Ordner: Fehlermeldung, aktueller Ordner bleibt
+        picker.navigate(&dir.path().join("gibt-es-nicht"));
+        assert!(picker.error.is_some());
+        assert_eq!(picker.dir, dir.path());
+    }
+
+    #[test]
+    fn test_parse_user_dirs() {
+        let home = Path::new("/home/anna");
+        let content = "# Kommentar\nXDG_DESKTOP_DIR=\"$HOME/Schreibtisch\"\nXDG_PICTURES_DIR=\"$HOME/Bilder\"\nXDG_MUSIC_DIR=\"/daten/Musik\"\n";
+        assert_eq!(
+            parse_user_dir(content, "XDG_PICTURES_DIR", home),
+            Some(PathBuf::from("/home/anna/Bilder"))
+        );
+        assert_eq!(
+            parse_user_dir(content, "XDG_MUSIC_DIR", home),
+            Some(PathBuf::from("/daten/Musik"))
+        );
+        assert_eq!(parse_user_dir(content, "XDG_DOWNLOAD_DIR", home), None);
+    }
+}

src/filter.rs

@@ -265,9 +265,18 @@ mod tests {
         // 4. dt > 1.0 s (großer Zeitsprung z.B. auf t = 5.0 s): Muss reset() auslösen
         let (x4, y4, p4) = filter.filter(50.0, 100.0, 0.9, 5.0);
         // Nach dem Reset muss der Filter sofort exakt den neuen Punkt als Startpunkt annehmen
-        assert_eq!(x4, 50.0, "Nach Reset muss der neue X-Wert übernommen werden");
-        assert_eq!(y4, 100.0, "Nach Reset muss der neue Y-Wert übernommen werden");
-        assert_eq!(p4, 0.9, "Nach Reset muss der neue Druckwert übernommen werden");
+        assert_eq!(
+            x4, 50.0,
+            "Nach Reset muss der neue X-Wert übernommen werden"
+        );
+        assert_eq!(
+            y4, 100.0,
+            "Nach Reset muss der neue Y-Wert übernommen werden"
+        );
+        assert_eq!(
+            p4, 0.9,
+            "Nach Reset muss der neue Druckwert übernommen werden"
+        );
     }
 
     #[test]
@@ -344,9 +353,18 @@ mod tests {
 
         // 2. Vergiftungsversuch mit NaN und Infinity
         let (x_nan, y_nan, p_nan) = filter.filter(f32::NAN, f32::INFINITY, f32::NEG_INFINITY, 0.02);
-        assert!(x_nan.is_finite(), "Filter darf kein NaN bei Vergiftung ausgeben");
-        assert!(y_nan.is_finite(), "Filter darf kein Inf bei Vergiftung ausgeben");
-        assert!(p_nan.is_finite(), "Filter darf kein -Inf bei Vergiftung ausgeben");
+        assert!(
+            x_nan.is_finite(),
+            "Filter darf kein NaN bei Vergiftung ausgeben"
+        );
+        assert!(
+            y_nan.is_finite(),
+            "Filter darf kein Inf bei Vergiftung ausgeben"
+        );
+        assert!(
+            p_nan.is_finite(),
+            "Filter darf kein -Inf bei Vergiftung ausgeben"
+        );
 
         let (x_nan2, y_nan2, p_nan2) = filter.filter(12.0, 22.0, 0.6, f64::NAN);
         assert!(x_nan2.is_finite());
@@ -364,6 +382,9 @@ mod tests {
         assert!(x3.is_finite());
         assert!(y3.is_finite());
         assert!(p3.is_finite());
-        assert!(x3 > x2, "Filter muss sich nach Vergiftung weiter normal anpassen");
+        assert!(
+            x3 > x2,
+            "Filter muss sich nach Vergiftung weiter normal anpassen"
+        );
     }
 }

src/history.rs

@@ -18,6 +18,13 @@ pub enum HistoryAction {
         before: Vec<Stroke>,
         after: Vec<Stroke>,
     },
+    /// Teilradierer: Striche wurden durch ihre übrig gebliebenen Stücke ersetzt.
+    SplitStrokes {
+        removed: Vec<Stroke>,
+        added: Vec<Stroke>,
+        /// Zeitpunkt des letzten Schnitts (zum Zusammenfassen eines Radierzugs)
+        at: std::time::Instant,
+    },
 }
 
 /// History-Stack für Transaktionsverwaltung (Undo / Redo).
@@ -41,6 +48,40 @@ impl HistoryStack {
         self.redo_stack.clear();
     }
 
+    /// Registriert einen Teilradier-Schnitt. Folgt er innerhalb von
+    /// [`crate::document::PARTIAL_ERASE_MERGE_WINDOW`] auf einen vorherigen, werden beide zu
+    /// einem Undo-Schritt zusammengefasst: Stücke, die im selben Zug wieder zerschnitten
+    /// wurden, verschwinden aus der Bilanz.
+    pub fn push_split(&mut self, removed: Vec<Stroke>, added: Vec<Stroke>) {
+        let now = std::time::Instant::now();
+        if let Some(HistoryAction::SplitStrokes {
+            removed: prev_removed,
+            added: prev_added,
+            at,
+        }) = self.undo_stack.last_mut()
+        {
+            if now.duration_since(*at) <= crate::document::PARTIAL_ERASE_MERGE_WINDOW
+                && self.redo_stack.is_empty()
+            {
+                for stroke in removed {
+                    if let Some(pos) = prev_added.iter().position(|s| s.id == stroke.id) {
+                        prev_added.remove(pos);
+                    } else {
+                        prev_removed.push(stroke);
+                    }
+                }
+                prev_added.extend(added);
+                *at = now;
+                return;
+            }
+        }
+        self.push(HistoryAction::SplitStrokes {
+            removed,
+            added,
+            at: now,
+        });
+    }
+
     /// Gibt zurück, ob Undo verfügbar ist.
     pub fn can_undo(&self) -> bool {
         !self.undo_stack.is_empty()
@@ -83,7 +124,8 @@ impl HistoryStack {
                 if let Some(pos) = strokes.iter().position(|s| s.id == new.id) {
                     strokes[pos] = old.clone();
                 }
-                self.redo_stack.push(HistoryAction::ReplaceStroke { old, new });
+                self.redo_stack
+                    .push(HistoryAction::ReplaceStroke { old, new });
             }
             HistoryAction::ModifyStrokes { before, after } => {
                 for b in &before {
@@ -91,7 +133,14 @@ impl HistoryStack {
                         strokes[pos] = b.clone();
                     }
                 }
-                self.redo_stack.push(HistoryAction::ModifyStrokes { before, after });
+                self.redo_stack
+                    .push(HistoryAction::ModifyStrokes { before, after });
+            }
+            HistoryAction::SplitStrokes { removed, added, at } => {
+                strokes.retain(|s| !added.iter().any(|a| a.id == s.id));
+                strokes.extend(removed.iter().cloned());
+                self.redo_stack
+                    .push(HistoryAction::SplitStrokes { removed, added, at });
             }
         }
 
@@ -126,7 +175,8 @@ impl HistoryStack {
                 if let Some(pos) = strokes.iter().position(|s| s.id == old.id) {
                     strokes[pos] = new.clone();
                 }
-                self.undo_stack.push(HistoryAction::ReplaceStroke { old, new });
+                self.undo_stack
+                    .push(HistoryAction::ReplaceStroke { old, new });
             }
             HistoryAction::ModifyStrokes { before, after } => {
                 for a in &after {
@@ -134,7 +184,14 @@ impl HistoryStack {
                         strokes[pos] = a.clone();
                     }
                 }
-                self.undo_stack.push(HistoryAction::ModifyStrokes { before, after });
+                self.undo_stack
+                    .push(HistoryAction::ModifyStrokes { before, after });
+            }
+            HistoryAction::SplitStrokes { removed, added, at } => {
+                strokes.retain(|s| !removed.iter().any(|r| r.id == s.id));
+                strokes.extend(added.iter().cloned());
+                self.undo_stack
+                    .push(HistoryAction::SplitStrokes { removed, added, at });
             }
         }
 

src/image_layer.rs

@@ -0,0 +1,392 @@
+//! GPU-Darstellung eingefügter Bilder: ein texturiertes Viereck pro Bild, gezeichnet nach dem
+//! Papier und vor der Tinte.
+//!
+//! Texturen liefert beim ersten Bedarf eine Texturquelle (Bilddatei oder gerenderte
+//! PDF-Seite); sie werden mit Mipmaps versehen, damit verkleinerte Bilder beim
+//! Herauszoomen nicht flimmern.
+
+use std::collections::{HashMap, HashSet};
+
+use crate::assets::RgbaImage;
+
+/// Vertex eines Bildvierecks: Seitenkoordinate und Texturkoordinate.
+#[repr(C)]
+#[derive(Copy, Clone, Debug, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct ImageVertex {
+    pub position: [f32; 2],
+    pub uv: [f32; 2],
+}
+
+impl ImageVertex {
+    const ATTRIBUTES: [wgpu::VertexAttribute; 2] =
+        wgpu::vertex_attr_array![0 => Float32x2, 1 => Float32x2];
+
+    fn desc() -> wgpu::VertexBufferLayout<'static> {
+        wgpu::VertexBufferLayout {
+            array_stride: std::mem::size_of::<ImageVertex>() as wgpu::BufferAddress,
+            step_mode: wgpu::VertexStepMode::Vertex,
+            attributes: &Self::ATTRIBUTES,
+        }
+    }
+}
+
+/// Zwei Dreiecke für ein Bild mit den Ecken oben links, oben rechts, unten rechts, unten links.
+pub fn quad_vertices(corners: &[glam::Vec2; 4]) -> [ImageVertex; 6] {
+    let v = |i: usize, uv: [f32; 2]| ImageVertex {
+        position: corners[i].to_array(),
+        uv,
+    };
+    let (tl, tr, br, bl) = (
+        v(0, [0.0, 0.0]),
+        v(1, [1.0, 0.0]),
+        v(2, [1.0, 1.0]),
+        v(3, [0.0, 1.0]),
+    );
+    [tl, tr, bl, bl, tr, br]
+}
+
+/// Mipmap-Stufen eines Bildes, jeweils halbe Kantenlänge bis 1 × 1.
+pub fn mip_chain(base: &RgbaImage) -> Vec<RgbaImage> {
+    let mut levels = vec![base.clone()];
+    let Some(mut current) =
+        image::RgbaImage::from_raw(base.width, base.height, base.pixels.clone())
+    else {
+        return levels;
+    };
+    while current.width() > 1 || current.height() > 1 {
+        let (w, h) = ((current.width() / 2).max(1), (current.height() / 2).max(1));
+        current = image::imageops::resize(&current, w, h, image::imageops::FilterType::Triangle);
+        levels.push(RgbaImage {
+            width: w,
+            height: h,
+            pixels: current.as_raw().clone(),
+        });
+    }
+    levels
+}
+
+/// Name der Ersatztextur für Bilder, deren Datei fehlt oder beschädigt ist.
+const MISSING: &str = "";
+/// Bis zu dieser Grafikspeichermenge bleiben Texturen anderer Seiten erhalten (schnelles
+/// Zurückblättern); darüber werden alle nicht mehr sichtbaren freigegeben.
+const TEXTURE_CACHE_BYTES: u64 = 384 * 1024 * 1024;
+
+/// Antwort einer Texturquelle für einen Schlüssel.
+pub enum TextureSource {
+    Ready(RgbaImage),
+    /// Wird gerade erzeugt; später erneut fragen
+    Pending,
+    Failed(String),
+}
+
+pub struct ImageLayer {
+    pipeline: wgpu::RenderPipeline,
+    texture_layout: wgpu::BindGroupLayout,
+    sampler: wgpu::Sampler,
+    /// Texturen nach Schlüssel (Asset-Name bzw. `<pdf>#<seite>`) mit belegtem Speicher
+    textures: HashMap<String, (wgpu::BindGroup, u64)>,
+    texture_bytes: u64,
+    /// Bilder der aktuellen Seite: Asset-Name und Ecken
+    quads: Vec<(String, [glam::Vec2; 4])>,
+    vertex_buffer: Option<wgpu::Buffer>,
+    vertices_dirty: bool,
+}
+
+impl ImageLayer {
+    pub fn new(
+        device: &wgpu::Device,
+        shader: &wgpu::ShaderModule,
+        camera_layout: &wgpu::BindGroupLayout,
+        format: wgpu::TextureFormat,
+    ) -> Self {
+        let texture_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Image Texture Bind Group Layout"),
+            entries: &[
+                wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Texture {
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                    count: None,
+                },
+            ],
+        });
+        let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("Image Pipeline Layout"),
+            bind_group_layouts: &[camera_layout, &texture_layout],
+            push_constant_ranges: &[],
+        });
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("Image Render Pipeline"),
+            layout: Some(&layout),
+            vertex: wgpu::VertexState {
+                module: shader,
+                entry_point: "vs_image",
+                buffers: &[ImageVertex::desc()],
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: shader,
+                entry_point: "fs_image",
+                targets: &[Some(wgpu::ColorTargetState {
+                    format,
+                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            primitive: wgpu::PrimitiveState {
+                topology: wgpu::PrimitiveTopology::TriangleList,
+                ..Default::default()
+            },
+            depth_stencil: None,
+            multisample: wgpu::MultisampleState::default(),
+            multiview: None,
+        });
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            label: Some("Image Sampler"),
+            address_mode_u: wgpu::AddressMode::ClampToEdge,
+            address_mode_v: wgpu::AddressMode::ClampToEdge,
+            mag_filter: wgpu::FilterMode::Linear,
+            min_filter: wgpu::FilterMode::Linear,
+            mipmap_filter: wgpu::FilterMode::Linear,
+            ..Default::default()
+        });
+
+        Self {
+            pipeline,
+            texture_layout,
+            sampler,
+            textures: HashMap::new(),
+            texture_bytes: 0,
+            quads: Vec::new(),
+            vertex_buffer: None,
+            vertices_dirty: false,
+        }
+    }
+
+    /// Übernimmt die Bilder der aktuellen Seite (Asset-Name und Ecken in Seitenkoordinaten).
+    pub fn set_quads(&mut self, quads: Vec<(String, [glam::Vec2; 4])>) {
+        if quads != self.quads {
+            self.quads = quads;
+            self.vertices_dirty = true;
+        }
+    }
+
+    /// Lädt fehlende Texturen und den Vertex-Puffer hoch. Vor jedem Zeichnen aufrufen;
+    /// ohne Änderungen kostet das nichts.
+    pub fn prepare(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        load: &mut dyn FnMut(&str) -> TextureSource,
+    ) {
+        let missing: Vec<String> = self
+            .quads
+            .iter()
+            .map(|(key, _)| key)
+            .filter(|key| !self.textures.contains_key(*key))
+            .cloned()
+            .collect();
+        for key in missing {
+            if self.textures.contains_key(&key) {
+                continue;
+            }
+            let (bind_group, bytes) = match load(&key) {
+                TextureSource::Ready(image) => (
+                    self.upload_texture(device, queue, &key, &image),
+                    image.pixels.len() as u64 * 4 / 3,
+                ),
+                // Noch in Arbeit (PDF-Seite wird gerendert): beim nächsten Bild erneut fragen
+                TextureSource::Pending => continue,
+                TextureSource::Failed(err) => {
+                    eprintln!("[Bilder] '{key}' kann nicht angezeigt werden: {err}");
+                    (self.missing_texture(device, queue), 4)
+                }
+            };
+            self.texture_bytes += bytes;
+            self.textures.insert(key, (bind_group, bytes));
+        }
+
+        // Nicht mehr benötigte Texturen freigeben, wenn der Grafikspeicher knapp wird
+        if self.texture_bytes > TEXTURE_CACHE_BYTES {
+            let used: HashSet<&String> = self.quads.iter().map(|(a, _)| a).collect();
+            self.textures.retain(|name, _| used.contains(name));
+            self.texture_bytes = self.textures.values().map(|(_, b)| b).sum();
+        }
+
+        if !self.vertices_dirty {
+            return;
+        }
+        self.vertices_dirty = false;
+        let vertices: Vec<ImageVertex> = self
+            .quads
+            .iter()
+            .flat_map(|(_, corners)| quad_vertices(corners))
+            .collect();
+        if vertices.is_empty() {
+            return;
+        }
+        let bytes: &[u8] = bytemuck::cast_slice(&vertices);
+        let too_small = self
+            .vertex_buffer
+            .as_ref()
+            .is_none_or(|b| b.size() < bytes.len() as u64);
+        if too_small {
+            self.vertex_buffer = Some(device.create_buffer(&wgpu::BufferDescriptor {
+                label: Some("Image Vertex Buffer"),
+                size: (bytes.len() as u64 * 2).max(1024),
+                usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
+                mapped_at_creation: false,
+            }));
+        }
+        if let Some(buffer) = &self.vertex_buffer {
+            queue.write_buffer(buffer, 0, bytes);
+        }
+    }
+
+    /// Fehlen noch Texturen der aktuellen Seite (z. B. PDF-Seite im Hintergrund-Rendering)?
+    pub fn is_waiting(&self) -> bool {
+        self.quads
+            .iter()
+            .any(|(key, _)| !self.textures.contains_key(key))
+    }
+
+    /// Zeichnet die Bilder der aktuellen Seite. Bind Group 0 (Kamera) muss gesetzt sein.
+    pub fn draw<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>) {
+        let Some(buffer) = &self.vertex_buffer else {
+            return;
+        };
+        if self.quads.is_empty() || self.vertices_dirty {
+            return;
+        }
+        render_pass.set_pipeline(&self.pipeline);
+        render_pass.set_vertex_buffer(0, buffer.slice(..));
+        for (i, (asset, _)) in self.quads.iter().enumerate() {
+            let Some((bind_group, _)) = self.textures.get(asset) else {
+                continue;
+            };
+            render_pass.set_bind_group(1, bind_group, &[]);
+            let start = (i * 6) as u32;
+            render_pass.draw(start..start + 6, 0..1);
+        }
+    }
+
+    fn missing_texture(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) -> wgpu::BindGroup {
+        // Hellgraue Fläche statt eines unsichtbaren Bildes
+        let gray = RgbaImage {
+            width: 1,
+            height: 1,
+            pixels: vec![200, 200, 200, 255],
+        };
+        self.upload_texture(device, queue, MISSING, &gray)
+    }
+
+    fn upload_texture(
+        &self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        label: &str,
+        image: &RgbaImage,
+    ) -> wgpu::BindGroup {
+        let levels = mip_chain(image);
+        let texture = device.create_texture(&wgpu::TextureDescriptor {
+            label: Some(label),
+            size: wgpu::Extent3d {
+                width: image.width,
+                height: image.height,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: levels.len() as u32,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: wgpu::TextureFormat::Rgba8UnormSrgb,
+            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+            view_formats: &[],
+        });
+        for (level, mip) in levels.iter().enumerate() {
+            queue.write_texture(
+                wgpu::ImageCopyTexture {
+                    texture: &texture,
+                    mip_level: level as u32,
+                    origin: wgpu::Origin3d::ZERO,
+                    aspect: wgpu::TextureAspect::All,
+                },
+                &mip.pixels,
+                wgpu::ImageDataLayout {
+                    offset: 0,
+                    bytes_per_row: Some(4 * mip.width),
+                    rows_per_image: Some(mip.height),
+                },
+                wgpu::Extent3d {
+                    width: mip.width,
+                    height: mip.height,
+                    depth_or_array_layers: 1,
+                },
+            );
+        }
+        let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
+        device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("Image Texture Bind Group"),
+            layout: &self.texture_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(&view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::Sampler(&self.sampler),
+                },
+            ],
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_quad_vertices_map_corners_to_texture_corners() {
+        let corners = [
+            glam::Vec2::new(10.0, 10.0),
+            glam::Vec2::new(50.0, 10.0),
+            glam::Vec2::new(50.0, 30.0),
+            glam::Vec2::new(10.0, 30.0),
+        ];
+        let quad = quad_vertices(&corners);
+        for v in quad {
+            // Texturkoordinate entspricht der relativen Lage im Rechteck
+            let u = (v.position[0] - 10.0) / 40.0;
+            let w = (v.position[1] - 10.0) / 20.0;
+            assert_eq!(v.uv, [u, w]);
+        }
+        // Beide Dreiecke decken alle vier Ecken ab
+        for c in corners {
+            assert!(quad.iter().any(|v| v.position == c.to_array()));
+        }
+    }
+
+    #[test]
+    fn test_mip_chain_halves_down_to_one_pixel() {
+        let base = RgbaImage {
+            width: 8,
+            height: 3,
+            pixels: vec![128; 8 * 3 * 4],
+        };
+        let levels = mip_chain(&base);
+        let sizes: Vec<(u32, u32)> = levels.iter().map(|l| (l.width, l.height)).collect();
+        assert_eq!(sizes, vec![(8, 3), (4, 1), (2, 1), (1, 1)]);
+        for l in &levels {
+            assert_eq!(l.pixels.len(), (l.width * l.height * 4) as usize);
+        }
+    }
+}

src/lib.rs

@@ -1,14 +1,22 @@
 //! ink-notes: Latenzoptimierte Inking-App für Linux.
 
+pub mod assets;
 pub mod autosave;
 pub mod background;
 pub mod canvas;
 pub mod document;
 pub mod export;
+pub mod file_picker;
 pub mod filter;
 pub mod geometry;
 pub mod history;
+pub mod image_layer;
+pub mod page_export;
+pub mod pdf_doc;
+pub mod pdf_merge;
+pub mod platform;
 pub mod selection;
+pub mod settings;
 pub mod spline;
 pub mod storage;
 pub mod ui;

src/page_export.rs

@@ -0,0 +1,233 @@
+//! Export einzelner Seiten als PNG oder SVG und einer Auswahl als Bild.
+//!
+//! Grundlage ist immer der PDF-Export: die Seite wird als einseitiges PDF erzeugt (mit
+//! Bildern, importierten PDF-Seiten und Formen) und anschließend mit `hayro` gerastert bzw.
+//! mit `hayro-svg` nach SVG umgewandelt. So sehen PDF, PNG und SVG gleich aus.
+
+use std::error::Error;
+
+use hayro::hayro_interpret::InterpreterSettings;
+use hayro::hayro_syntax::Pdf;
+use hayro::vello_cpu::color::palette::css::{TRANSPARENT, WHITE};
+use hayro::{PixmapSettings, RenderCache, RenderSettings};
+
+use crate::assets::{AssetStore, RgbaImage};
+use crate::document::{Aabb, Notebook, Page, PageBackground, A4_WIDTH_MM, PAGE_WIDTH};
+use crate::export::{export_notebook_to_bytes, ExportStrategy};
+
+/// Auflösung des PNG-Exports einer Seite.
+pub const PAGE_PNG_DPI: f32 = 200.0;
+/// Auflösung einer in die Zwischenablage kopierten Auswahl.
+pub const SELECTION_PNG_DPI: f32 = 150.0;
+
+/// Hintergrund beim Bild-Export.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ImageBackground {
+    /// Weißes Papier mit Raster bzw. importierter PDF-Seite
+    Paper,
+    /// Transparent, nur Bilder und Tinte (ohne Raster und ohne importierte PDF-Seite)
+    Transparent,
+}
+
+/// Erzeugt ein einseitiges PDF aus `page`.
+fn single_page_pdf(page: &Page, assets: Option<&AssetStore>) -> Result<Vec<u8>, Box<dyn Error>> {
+    let notebook = Notebook::from_pages(vec![page.clone()], 0, 1, page.id + 1);
+    export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, assets)
+}
+
+/// Seite ohne Raster und PDF-Hintergrund (für transparenten Export und Auswahlen).
+fn content_only(page: &Page) -> Page {
+    let mut page = page.clone();
+    page.background = PageBackground::Blank;
+    page.pdf_background = None;
+    page
+}
+
+/// Rastert die erste Seite eines PDFs mit `dpi`; Farben ohne Vormultiplikation.
+fn rasterize(pdf_bytes: Vec<u8>, dpi: f32, transparent: bool) -> Result<RgbaImage, Box<dyn Error>> {
+    let pdf = Pdf::new(pdf_bytes).map_err(|e| format!("PDF nicht lesbar: {e:?}"))?;
+    let page = pdf.pages().first().ok_or("PDF ohne Seite")?;
+    let scale = dpi / 72.0;
+    let pixmap = hayro::render(
+        page,
+        &RenderCache::new(),
+        &InterpreterSettings::default(),
+        &RenderSettings::default(),
+        &PixmapSettings {
+            x_scale: scale,
+            y_scale: scale,
+            bg_color: if transparent { TRANSPARENT } else { WHITE },
+        },
+    );
+    let mut pixels = pixmap.data_as_u8_slice().to_vec();
+    // hayro liefert vormultiplizierte Farben; PNG erwartet gerade Farben
+    for px in pixels.as_chunks_mut::<4>().0 {
+        let a = px[3] as u32;
+        if a > 0 && a < 255 {
+            for c in &mut px[..3] {
+                *c = ((*c as u32 * 255 + a / 2) / a).min(255) as u8;
+            }
+        }
+    }
+    Ok(RgbaImage {
+        width: pixmap.width() as u32,
+        height: pixmap.height() as u32,
+        pixels,
+    })
+}
+
+/// Kodiert ein Bild als PNG.
+pub fn encode_png(image: &RgbaImage) -> Result<Vec<u8>, Box<dyn Error>> {
+    let buffer = image::RgbaImage::from_raw(image.width, image.height, image.pixels.clone())
+        .ok_or("Pixeldaten passen nicht zur Bildgröße")?;
+    let mut out = Vec::new();
+    image::DynamicImage::ImageRgba8(buffer)
+        .write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png)?;
+    Ok(out)
+}
+
+/// Seite als PNG (A4 mit [`PAGE_PNG_DPI`]).
+pub fn page_png(
+    page: &Page,
+    assets: Option<&AssetStore>,
+    background: ImageBackground,
+) -> Result<Vec<u8>, Box<dyn Error>> {
+    let image = match background {
+        ImageBackground::Paper => rasterize(single_page_pdf(page, assets)?, PAGE_PNG_DPI, false)?,
+        ImageBackground::Transparent => rasterize(
+            single_page_pdf(&content_only(page), assets)?,
+            PAGE_PNG_DPI,
+            true,
+        )?,
+    };
+    encode_png(&image)
+}
+
+/// Seite als SVG (Vektor; Schriften importierter PDFs werden zu Pfaden).
+pub fn page_svg(page: &Page, assets: Option<&AssetStore>) -> Result<String, Box<dyn Error>> {
+    let pdf =
+        Pdf::new(single_page_pdf(page, assets)?).map_err(|e| format!("PDF nicht lesbar: {e:?}"))?;
+    let pdf_page = pdf.pages().first().ok_or("PDF ohne Seite")?;
+    Ok(hayro_svg::convert(
+        pdf_page,
+        &hayro_svg::RenderCache::new(),
+        &InterpreterSettings::default(),
+        &hayro_svg::SvgRenderSettings {
+            bg_color: [255, 255, 255, 255],
+        },
+    ))
+}
+
+/// Bild der Objekte `ids` auf `page`, auf ihren Umriss zugeschnitten, mit transparentem
+/// Hintergrund. `None`, wenn keines der Objekte auf der Seite liegt.
+pub fn selection_image(
+    page: &Page,
+    ids: &[u64],
+    assets: Option<&AssetStore>,
+) -> Result<Option<RgbaImage>, Box<dyn Error>> {
+    let mut selected = content_only(page);
+    selected.strokes.retain(|s| ids.contains(&s.id));
+    let Some(bounds) = Page::selection_aabb(&selected.strokes) else {
+        return Ok(None);
+    };
+    let max_width = selected.strokes.iter().map(|s| s.width).fold(0.0, f32::max);
+    let bounds: Aabb = bounds.expanded(max_width / 2.0 + 4.0);
+
+    let full = rasterize(single_page_pdf(&selected, assets)?, SELECTION_PNG_DPI, true)?;
+    // Seiteneinheiten → Pixel
+    let px_per_unit = SELECTION_PNG_DPI / 25.4 * A4_WIDTH_MM / PAGE_WIDTH;
+    let x0 = ((bounds.min.x * px_per_unit).floor().max(0.0) as u32).min(full.width);
+    let y0 = ((bounds.min.y * px_per_unit).floor().max(0.0) as u32).min(full.height);
+    let x1 = ((bounds.max.x * px_per_unit).ceil().max(0.0) as u32).min(full.width);
+    let y1 = ((bounds.max.y * px_per_unit).ceil().max(0.0) as u32).min(full.height);
+    if x1 <= x0 || y1 <= y0 {
+        return Ok(None);
+    }
+    let (w, h) = (x1 - x0, y1 - y0);
+    let mut pixels = Vec::with_capacity((w * h * 4) as usize);
+    for y in y0..y1 {
+        let start = ((y * full.width + x0) * 4) as usize;
+        pixels.extend_from_slice(&full.pixels[start..start + (w * 4) as usize]);
+    }
+    Ok(Some(RgbaImage {
+        width: w,
+        height: h,
+        pixels,
+    }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::document::{Stroke, StylusSample, PAGE_HEIGHT};
+
+    fn page_with_line() -> Page {
+        let mut page = Page::new(1, PageBackground::Grid5mm);
+        let samples: Vec<StylusSample> = (0..=20)
+            .map(|i| StylusSample {
+                position: glam::Vec2::new(500.0 + i as f32 * 20.0, 1000.0),
+                pressure: 0.6,
+                timestamp: i as f64 * 0.01,
+            })
+            .collect();
+        let vertices = crate::storage::reconstruct_stroke_vertices(
+            &samples,
+            [0.9, 0.1, 0.1, 1.0],
+            20.0,
+            Default::default(),
+            true,
+        );
+        let mut stroke = Stroke::new(7, samples, vertices, [0.9, 0.1, 0.1, 1.0]);
+        stroke.width = 20.0;
+        page.strokes.push(stroke);
+        page
+    }
+
+    fn decode(png: &[u8]) -> image::RgbaImage {
+        image::load_from_memory(png).unwrap().into_rgba8()
+    }
+
+    #[test]
+    fn test_page_png_paper_and_transparent() {
+        let page = page_with_line();
+        let paper = decode(&page_png(&page, None, ImageBackground::Paper).unwrap());
+        // A4 mit 200 dpi
+        assert_eq!(paper.width(), (A4_WIDTH_MM / 25.4 * PAGE_PNG_DPI) as u32);
+        assert_eq!(paper.get_pixel(5, 5).0[3], 255, "Papier ist deckend");
+
+        let clear = decode(&page_png(&page, None, ImageBackground::Transparent).unwrap());
+        assert_eq!(clear.get_pixel(5, 5).0[3], 0, "Hintergrund ist transparent");
+        // Die Linie ist rot und deckend
+        let px_per_unit = clear.width() as f32 / PAGE_WIDTH;
+        let line = clear.get_pixel((700.0 * px_per_unit) as u32, (1000.0 * px_per_unit) as u32);
+        assert!(
+            line.0[0] > 180 && line.0[1] < 80 && line.0[3] > 200,
+            "{line:?}"
+        );
+        assert!(clear.height() as f32 / clear.width() as f32 - PAGE_HEIGHT / PAGE_WIDTH < 0.01);
+    }
+
+    #[test]
+    fn test_page_svg_contains_ink() {
+        let svg = page_svg(&page_with_line(), None).unwrap();
+        assert!(svg.starts_with("<svg") || svg.contains("<svg"));
+        assert!(svg.contains("<path"));
+        assert!(svg.trim_end().ends_with("</svg>"));
+    }
+
+    #[test]
+    fn test_selection_image_is_cropped() {
+        let page = page_with_line();
+        let image = selection_image(&page, &[7], None).unwrap().unwrap();
+        // Linie 400 Einheiten (40 mm) lang: Bild etwas breiter als 40 mm bei 150 dpi
+        let expected = 40.0 / 25.4 * SELECTION_PNG_DPI;
+        assert!(
+            (image.width as f32) > expected && (image.width as f32) < expected * 1.25,
+            "{} px",
+            image.width
+        );
+        assert!(image.height < image.width / 3);
+        assert!(image.pixels.as_chunks::<4>().0.iter().any(|p| p[3] > 200));
+        assert!(selection_image(&page, &[99], None).unwrap().is_none());
+    }
+}

src/pdf_doc.rs

@@ -0,0 +1,291 @@
+//! Lesen und Rendern importierter PDF-Dateien mit `hayro` (reines Rust, nur CPU).
+//!
+//! Das Rendern einer Seite kann einige hundert Millisekunden dauern; [`PdfRenderService`]
+//! erledigt es deshalb in einem Hintergrund-Thread und meldet fertige Seiten zurück.
+
+use std::collections::{HashMap, HashSet};
+use std::path::PathBuf;
+use std::sync::mpsc::{self, Receiver, Sender};
+
+use hayro::hayro_interpret::InterpreterSettings;
+use hayro::hayro_syntax::{LoadPdfError, Pdf};
+use hayro::vello_cpu::color::palette::css::WHITE;
+use hayro::{PixmapSettings, RenderCache, RenderSettings};
+
+use crate::assets::RgbaImage;
+
+/// Längste Kante einer gerenderten Seite für die Anzeige in Pixeln (A4 ≈ 220 dpi).
+pub const DISPLAY_RENDER_PIXELS: u32 = 2560;
+/// Größte Seitenzahl, die importiert wird.
+pub const MAX_IMPORT_PAGES: usize = 2000;
+
+/// Öffnet ein PDF und liefert die angezeigte Größe jeder Seite in Punkt (Drehung
+/// berücksichtigt).
+pub fn page_sizes(bytes: Vec<u8>) -> Result<Vec<(f32, f32)>, String> {
+    let pdf = open(bytes)?;
+    let sizes: Vec<(f32, f32)> = pdf.pages().iter().map(|p| p.render_dimensions()).collect();
+    if sizes.is_empty() {
+        return Err("Das PDF enthält keine Seiten".into());
+    }
+    if sizes.len() > MAX_IMPORT_PAGES {
+        return Err(format!(
+            "Das PDF hat {} Seiten, höchstens {MAX_IMPORT_PAGES} werden unterstützt",
+            sizes.len()
+        ));
+    }
+    Ok(sizes)
+}
+
+fn open(bytes: Vec<u8>) -> Result<Pdf, String> {
+    Pdf::new(bytes).map_err(|e| match e {
+        LoadPdfError::Decryption(_) => {
+            "Das PDF ist verschlüsselt oder passwortgeschützt und kann nicht geöffnet werden"
+                .to_string()
+        }
+        LoadPdfError::Invalid => "Die Datei ist kein lesbares PDF".to_string(),
+    })
+}
+
+/// Rendert Seite `index` so, dass die längste Kante höchstens `max_pixels` lang ist,
+/// auf weißem Grund.
+pub fn render_page(pdf: &Pdf, index: usize, max_pixels: u32) -> Result<RgbaImage, String> {
+    let page = pdf
+        .pages()
+        .get(index)
+        .ok_or_else(|| format!("Seite {} fehlt im PDF", index + 1))?;
+    let (w, h) = page.render_dimensions();
+    let scale = (max_pixels as f32 / w.max(h).max(1.0)).min(16.0);
+    let pixmap = hayro::render(
+        page,
+        &RenderCache::new(),
+        &InterpreterSettings::default(),
+        &RenderSettings::default(),
+        &PixmapSettings {
+            x_scale: scale,
+            y_scale: scale,
+            bg_color: WHITE,
+        },
+    );
+    // Auf weißem Grund ist jedes Pixel deckend: vormultipliziert = gerade Farbe
+    Ok(RgbaImage {
+        width: pixmap.width() as u32,
+        height: pixmap.height() as u32,
+        pixels: pixmap.data_as_u8_slice().to_vec(),
+    })
+}
+
+/// Öffnet die Datei und rendert eine Seite (für den PDF-Export als Ersatzbild).
+pub fn render_file_page(
+    path: &std::path::Path,
+    index: usize,
+    max_pixels: u32,
+) -> Result<RgbaImage, String> {
+    let bytes = std::fs::read(path).map_err(|e| e.to_string())?;
+    render_page(&open(bytes)?, index, max_pixels)
+}
+
+struct RenderRequest {
+    key: String,
+    path: PathBuf,
+    page: usize,
+}
+
+/// Ergebnis eines Render-Auftrags.
+pub type RenderResult = Result<RgbaImage, String>;
+
+/// Rendert PDF-Seiten im Hintergrund. Fertige Seiten holt der Event-Loop mit
+/// [`PdfRenderService::take`] ab; `on_ready` weckt ihn dafür auf.
+pub struct PdfRenderService {
+    requests: Sender<RenderRequest>,
+    results: Receiver<(String, RenderResult)>,
+    pending: HashSet<String>,
+    ready: HashMap<String, RenderResult>,
+}
+
+impl PdfRenderService {
+    pub fn new(on_ready: impl Fn() + Send + 'static) -> Self {
+        let (req_tx, req_rx) = mpsc::channel::<RenderRequest>();
+        let (res_tx, res_rx) = mpsc::channel();
+        std::thread::Builder::new()
+            .name("pdf-render".into())
+            .spawn(move || {
+                // Zuletzt geöffnetes PDF behalten: Blättern rendert meist dieselbe Datei
+                let mut open_pdf: Option<(PathBuf, Pdf)> = None;
+                while let Ok(request) = req_rx.recv() {
+                    if open_pdf.as_ref().map(|(p, _)| p) != Some(&request.path) {
+                        open_pdf = std::fs::read(&request.path)
+                            .map_err(|e| e.to_string())
+                            .and_then(open)
+                            .map_err(|e| eprintln!("[PDF] '{}': {e}", request.path.display()))
+                            .ok()
+                            .map(|pdf| (request.path.clone(), pdf));
+                    }
+                    let result = match &open_pdf {
+                        Some((_, pdf)) => render_page(pdf, request.page, DISPLAY_RENDER_PIXELS),
+                        None => Err("PDF kann nicht geöffnet werden".into()),
+                    };
+                    if res_tx.send((request.key, result)).is_err() {
+                        break;
+                    }
+                    on_ready();
+                }
+            })
+            .expect("PDF-Render-Thread konnte nicht gestartet werden");
+        Self {
+            requests: req_tx,
+            results: res_rx,
+            pending: HashSet::new(),
+            ready: HashMap::new(),
+        }
+    }
+
+    /// Rendert eine Seite vorab (z. B. die nächste), ohne auf das Ergebnis zu warten;
+    /// [`Self::take`] liefert es später sofort.
+    pub fn prefetch(&mut self, key: &str, path: PathBuf, page: usize) {
+        self.collect();
+        if self.ready.contains_key(key) || self.pending.contains(key) {
+            return;
+        }
+        // Vorab gerenderte Seiten nicht unbegrenzt aufheben
+        if self.ready.len() >= 2 {
+            self.ready.clear();
+        }
+        self.request(key, path, page);
+    }
+
+    fn collect(&mut self) {
+        while let Ok((done, result)) = self.results.try_recv() {
+            self.pending.remove(&done);
+            self.ready.insert(done, result);
+        }
+    }
+
+    /// Erteilt den Auftrag, falls noch keiner läuft. `false`, wenn der Thread beendet ist.
+    fn request(&mut self, key: &str, path: PathBuf, page: usize) -> bool {
+        if !self.pending.insert(key.to_string()) {
+            return true;
+        }
+        let request = RenderRequest {
+            key: key.to_string(),
+            path,
+            page,
+        };
+        if self.requests.send(request).is_err() {
+            self.pending.remove(key);
+            return false;
+        }
+        true
+    }
+
+    /// Fertiges Ergebnis für `key` abholen; sonst den Auftrag (einmalig) erteilen und `None`.
+    pub fn take(&mut self, key: &str, path: PathBuf, page: usize) -> Option<RenderResult> {
+        self.collect();
+        if let Some(result) = self.ready.remove(key) {
+            return Some(result);
+        }
+        if !self.request(key, path, page) {
+            return Some(Err("PDF-Render-Thread beendet".into()));
+        }
+        None
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+
+    /// Minimales gültiges PDF mit Seiten der angegebenen Größen (Punkt); jede Seite zeigt ein
+    /// rotes Rechteck in der linken oberen Ecke. Optional mit `/Rotate`.
+    pub(crate) fn sample_pdf(pages: &[(f32, f32, i32)]) -> Vec<u8> {
+        let mut objects: Vec<String> = Vec::new();
+        let n = pages.len();
+        // 1: Katalog, 2: Seitenbaum, danach je Seite: Seite + Inhalt
+        objects.push("<< /Type /Catalog /Pages 2 0 R >>".into());
+        let kids: Vec<String> = (0..n).map(|i| format!("{} 0 R", 3 + 2 * i)).collect();
+        objects.push(format!(
+            "<< /Type /Pages /Kids [{}] /Count {n} >>",
+            kids.join(" ")
+        ));
+        for (i, (w, h, rotate)) in pages.iter().enumerate() {
+            let content_id = 4 + 2 * i;
+            objects.push(format!(
+                "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {w} {h}] /Rotate {rotate} /Contents {content_id} 0 R /Resources << >> >>"
+            ));
+            let content = format!("1 0 0 rg 0 {} 40 40 re f", h - 40.0);
+            objects.push(format!(
+                "<< /Length {} >>\nstream\n{content}\nendstream",
+                content.len()
+            ));
+        }
+        let mut out = b"%PDF-1.4\n".to_vec();
+        let mut offsets = Vec::new();
+        for (i, obj) in objects.iter().enumerate() {
+            offsets.push(out.len());
+            out.extend_from_slice(format!("{} 0 obj\n{obj}\nendobj\n", i + 1).as_bytes());
+        }
+        let xref_pos = out.len();
+        out.extend_from_slice(
+            format!("xref\n0 {}\n0000000000 65535 f \n", objects.len() + 1).as_bytes(),
+        );
+        for off in offsets {
+            out.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
+        }
+        out.extend_from_slice(
+            format!(
+                "trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref_pos}\n%%EOF\n",
+                objects.len() + 1
+            )
+            .as_bytes(),
+        );
+        out
+    }
+
+    #[test]
+    fn test_page_sizes_and_errors() {
+        let pdf = sample_pdf(&[(595.0, 842.0, 0), (842.0, 595.0, 0), (595.0, 842.0, 90)]);
+        let sizes = page_sizes(pdf).unwrap();
+        assert_eq!(sizes, vec![(595.0, 842.0), (842.0, 595.0), (842.0, 595.0)]);
+        assert!(page_sizes(b"kein pdf".to_vec()).is_err());
+    }
+
+    #[test]
+    fn test_render_page_draws_content() {
+        let pdf = open(sample_pdf(&[(200.0, 100.0, 0)])).unwrap();
+        let image = render_page(&pdf, 0, 400).unwrap();
+        assert_eq!((image.width, image.height), (400, 200));
+        let px = |x: u32, y: u32| {
+            let i = ((y * image.width + x) * 4) as usize;
+            &image.pixels[i..i + 4]
+        };
+        // Rotes Quadrat oben links, sonst weiß
+        assert_eq!(px(20, 20), &[255, 0, 0, 255]);
+        assert_eq!(px(300, 150), &[255, 255, 255, 255]);
+        assert!(render_page(&pdf, 5, 400).is_err());
+    }
+
+    #[test]
+    fn test_render_service_delivers_in_background() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("a.pdf");
+        std::fs::write(&path, sample_pdf(&[(400.0, 300.0, 0)])).unwrap();
+        let (wake_tx, wake_rx) = mpsc::channel();
+        let mut service = PdfRenderService::new(move || {
+            let _ = wake_tx.send(());
+        });
+        assert!(service.take("a#0", path.clone(), 0).is_none());
+        // Zweite Anfrage erteilt keinen weiteren Auftrag
+        assert!(service.take("a#0", path.clone(), 0).is_none());
+        wake_rx
+            .recv_timeout(std::time::Duration::from_secs(20))
+            .unwrap();
+        let image = service.take("a#0", path.clone(), 0).unwrap().unwrap();
+        assert_eq!(image.width, DISPLAY_RENDER_PIXELS);
+
+        // Vorab rendern: danach sofort verfügbar
+        service.prefetch("a#0", path.clone(), 0);
+        wake_rx
+            .recv_timeout(std::time::Duration::from_secs(20))
+            .unwrap();
+        assert!(service.take("a#0", path, 0).unwrap().is_ok());
+    }
+}

src/pdf_merge.rs

@@ -0,0 +1,383 @@
+//! Legt beim PDF-Export die Originalseiten importierter PDFs als Vektorgrafik unter die
+//! Notizen (Text bleibt scharf und auswählbar).
+//!
+//! Vorgehen: Das von printpdf erzeugte PDF wird mit `lopdf` geöffnet. Jede benötigte Seite
+//! des Quell-PDFs wird als Form-XObject (Inhalt + Ressourcen der Seite) übernommen und am
+//! Anfang der Zielseite gezeichnet, also unter Hintergrund, Bildern und Tinte.
+
+use std::collections::{BTreeMap, HashMap};
+
+use printpdf::lopdf::{Dictionary, Document, Object, ObjectId, Stream};
+
+/// Eine Zielseite, unter die eine Seite eines Quell-PDFs gelegt wird.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Underlay {
+    /// Seitennummer im Ziel-PDF, ab 0
+    pub target_page: usize,
+    /// Schlüssel des Quell-PDFs in `sources`
+    pub source: String,
+    /// Seitennummer im Quell-PDF, ab 0
+    pub source_page: usize,
+    /// Zielrechteck in PDF-Punkten (links, unten, Breite, Höhe; Ursprung unten links)
+    pub rect: [f32; 4],
+}
+
+/// Nicht übernommene Unterlagen samt Grund.
+pub type FailedUnderlays = Vec<(Underlay, String)>;
+
+/// Affine PDF-Matrix `[a b c d e f]`: x' = a·x + c·y + e, y' = b·x + d·y + f.
+pub type Matrix = [f32; 6];
+
+/// `outer ∘ inner`: erst `inner`, dann `outer` anwenden.
+pub fn compose(outer: Matrix, inner: Matrix) -> Matrix {
+    let [a1, b1, c1, d1, e1, f1] = outer;
+    let [a2, b2, c2, d2, e2, f2] = inner;
+    [
+        a1 * a2 + c1 * b2,
+        b1 * a2 + d1 * b2,
+        a1 * c2 + c1 * d2,
+        b1 * c2 + d1 * d2,
+        a1 * e2 + c1 * f2 + e1,
+        b1 * e2 + d1 * f2 + f1,
+    ]
+}
+
+/// Matrix, die den Seitenbereich `bbox` (links, unten, rechts, oben) einer um `rotate` Grad
+/// im Uhrzeigersinn gedrehten Seite so abbildet, wie ein Betrachter sie zeigt, eingepasst
+/// in `rect` (links, unten, Breite, Höhe).
+pub fn placement_matrix(bbox: [f32; 4], rotate: i64, rect: [f32; 4]) -> Matrix {
+    let (w, h) = ((bbox[2] - bbox[0]).max(1e-3), (bbox[3] - bbox[1]).max(1e-3));
+    let to_origin = [1.0, 0.0, 0.0, 1.0, -bbox[0], -bbox[1]];
+    let (rotation, shown_w, shown_h): (Matrix, f32, f32) = match rotate.rem_euclid(360) {
+        90 => ([0.0, -1.0, 1.0, 0.0, 0.0, w], h, w),
+        180 => ([-1.0, 0.0, 0.0, -1.0, w, h], w, h),
+        270 => ([0.0, 1.0, -1.0, 0.0, h, 0.0], h, w),
+        _ => ([1.0, 0.0, 0.0, 1.0, 0.0, 0.0], w, h),
+    };
+    let scale = (rect[2] / shown_w).min(rect[3] / shown_h);
+    let place = [scale, 0.0, 0.0, scale, rect[0], rect[1]];
+    compose(place, compose(rotation, to_origin))
+}
+
+/// Erbt ein Seitenattribut über die `Parent`-Kette.
+fn inherited<'a>(doc: &'a Document, page: &'a Dictionary, key: &[u8]) -> Option<&'a Object> {
+    let mut node = page;
+    for _ in 0..64 {
+        if let Ok(value) = node.get(key) {
+            return Some(value);
+        }
+        let parent = node.get(b"Parent").and_then(Object::as_reference).ok()?;
+        node = doc.get_dictionary(parent).ok()?;
+    }
+    None
+}
+
+fn resolve<'a>(doc: &'a Document, object: &'a Object) -> &'a Object {
+    doc.dereference(object).map(|(_, o)| o).unwrap_or(object)
+}
+
+fn read_box(doc: &Document, object: Option<&Object>) -> Option<[f32; 4]> {
+    let array = resolve(doc, object?).as_array().ok()?;
+    let values: Vec<f32> = array
+        .iter()
+        .filter_map(|v| resolve(doc, v).as_float().ok())
+        .collect();
+    let [x0, y0, x1, y1] = <[f32; 4]>::try_from(values).ok()?;
+    Some([x0.min(x1), y0.min(y1), x0.max(x1), y0.max(y1)])
+}
+
+/// Baut aus einer Seite des (bereits umnummerierten) Quelldokuments ein Form-XObject.
+/// Liefert das XObject und die Matrix für die Platzierung in `rect`.
+fn page_as_form(
+    doc: &Document,
+    page_id: ObjectId,
+    rect: [f32; 4],
+) -> Result<(Stream, Matrix), String> {
+    let page = doc.get_dictionary(page_id).map_err(|e| e.to_string())?;
+    let media =
+        read_box(doc, inherited(doc, page, b"MediaBox")).unwrap_or([0.0, 0.0, 595.0, 842.0]);
+    let bbox = match read_box(doc, inherited(doc, page, b"CropBox")) {
+        // Sichtbarer Bereich: Schnitt aus Crop- und Media-Box
+        Some(c) => [
+            c[0].max(media[0]),
+            c[1].max(media[1]),
+            c[2].min(media[2]),
+            c[3].min(media[3]),
+        ],
+        None => media,
+    };
+    let rotate = inherited(doc, page, b"Rotate")
+        .and_then(|r| resolve(doc, r).as_i64().ok())
+        .unwrap_or(0);
+    let resources = inherited(doc, page, b"Resources")
+        .cloned()
+        .unwrap_or_else(|| Object::Dictionary(Dictionary::new()));
+
+    // Ein einzelner Inhaltsstrom wird unverändert (samt Kompression) übernommen,
+    // mehrere werden entpackt und aneinandergehängt
+    let streams = doc.get_page_contents(page_id);
+    let (content, filter) = match streams.as_slice() {
+        [single] => {
+            let stream = doc
+                .get_object(*single)
+                .and_then(Object::as_stream)
+                .map_err(|e| e.to_string())?;
+            let filter = ["Filter", "DecodeParms"]
+                .into_iter()
+                .filter_map(|k| Some((k, stream.dict.get(k.as_bytes()).ok()?.clone())))
+                .collect::<Vec<_>>();
+            (stream.content.clone(), filter)
+        }
+        _ => {
+            let mut content = Vec::new();
+            for id in streams {
+                let stream = doc
+                    .get_object(id)
+                    .and_then(Object::as_stream)
+                    .map_err(|e| e.to_string())?;
+                let data = stream
+                    .decompressed_content()
+                    .map_err(|e| format!("Inhalt nicht lesbar: {e}"))?;
+                content.extend_from_slice(&data);
+                content.push(b'\n');
+            }
+            (content, Vec::new())
+        }
+    };
+
+    let mut dict = Dictionary::new();
+    dict.set("Type", Object::Name(b"XObject".to_vec()));
+    dict.set("Subtype", Object::Name(b"Form".to_vec()));
+    dict.set(
+        "BBox",
+        Object::Array(bbox.iter().map(|&v| Object::Real(v)).collect()),
+    );
+    dict.set("Resources", resources);
+    for (key, value) in filter {
+        dict.set(key, value);
+    }
+    Ok((
+        Stream::new(dict, content),
+        placement_matrix(bbox, rotate, rect),
+    ))
+}
+
+/// Legt die Quellseiten unter die Zielseiten. `sources` enthält die Quell-PDFs als Bytes.
+/// Gibt die neuen PDF-Bytes zurück und die Underlays, die nicht übernommen werden konnten
+/// (z. B. verschlüsselte PDFs), samt Grund.
+pub fn apply_underlays(
+    target_bytes: &[u8],
+    underlays: &[Underlay],
+    sources: &HashMap<String, Vec<u8>>,
+) -> Result<(Vec<u8>, FailedUnderlays), String> {
+    let mut target = Document::load_mem(target_bytes).map_err(|e| e.to_string())?;
+    let target_pages: Vec<ObjectId> = target.get_pages().into_values().collect();
+    let mut failed = Vec::new();
+
+    // Quell-PDFs einmal laden und mit freien Objektnummern in das Ziel übernehmen
+    let mut loaded: HashMap<&str, Result<BTreeMap<u32, ObjectId>, String>> = HashMap::new();
+    for underlay in underlays {
+        if loaded.contains_key(underlay.source.as_str()) {
+            continue;
+        }
+        let result = (|| {
+            let bytes = sources
+                .get(&underlay.source)
+                .ok_or_else(|| "Quell-PDF fehlt".to_string())?;
+            let mut source = Document::load_mem(bytes).map_err(|e| e.to_string())?;
+            if source.is_encrypted() {
+                return Err("Quell-PDF ist verschlüsselt".to_string());
+            }
+            source.renumber_objects_with(target.max_id + 1);
+            let pages = source.get_pages();
+            target.max_id = target.max_id.max(source.max_id);
+            // Katalog und Seitenbaum der Quelle werden nicht referenziert und beim Speichern
+            // mit `prune_objects` entfernt
+            target.objects.extend(source.objects);
+            Ok(pages)
+        })();
+        loaded.insert(&underlay.source, result);
+    }
+
+    for underlay in underlays {
+        let result = (|| {
+            let pages = loaded[underlay.source.as_str()]
+                .as_ref()
+                .map_err(Clone::clone)?;
+            let source_page = *pages
+                .get(&(underlay.source_page as u32 + 1))
+                .ok_or_else(|| format!("Seite {} fehlt im Quell-PDF", underlay.source_page + 1))?;
+            let target_page = *target_pages
+                .get(underlay.target_page)
+                .ok_or_else(|| "Zielseite fehlt".to_string())?;
+            let (form, matrix) = page_as_form(&target, source_page, underlay.rect)?;
+            let form_id = target.add_object(Object::Stream(form));
+            let name = format!("InkPdf{}", form_id.0);
+            add_xobject(&mut target, target_page, &name, form_id)?;
+            let ops = format!(
+                "q {} {} {} {} {} {} cm /{name} Do Q\n",
+                matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]
+            );
+            prepend_content(&mut target, target_page, ops.into_bytes())
+        })();
+        if let Err(err) = result {
+            failed.push((underlay.clone(), err));
+        }
+    }
+
+    target.prune_objects();
+    // Neue, noch unkomprimierte Ströme packen (bereits gefilterte bleiben unverändert)
+    target.compress();
+    let mut out = Vec::new();
+    target.save_to(&mut out).map_err(|e| e.to_string())?;
+    Ok((out, failed))
+}
+
+/// Trägt ein XObject in die Ressourcen der Seite ein.
+fn add_xobject(
+    doc: &mut Document,
+    page_id: ObjectId,
+    name: &str,
+    id: ObjectId,
+) -> Result<(), String> {
+    // Ressourcen der Seite als eigenes Wörterbuch an der Seite (geerbte werden übernommen)
+    let resources = {
+        let page = doc.get_dictionary(page_id).map_err(|e| e.to_string())?;
+        match inherited(doc, page, b"Resources").map(|r| resolve(doc, r)) {
+            Some(Object::Dictionary(d)) => d.clone(),
+            _ => Dictionary::new(),
+        }
+    };
+    let mut xobjects = match resources.get(b"XObject").map(|x| resolve(doc, x)) {
+        Ok(Object::Dictionary(d)) => d.clone(),
+        _ => Dictionary::new(),
+    };
+    xobjects.set(name, Object::Reference(id));
+    let mut resources = resources;
+    resources.set("XObject", Object::Dictionary(xobjects));
+    let page = doc
+        .get_object_mut(page_id)
+        .and_then(Object::as_dict_mut)
+        .map_err(|e| e.to_string())?;
+    page.set("Resources", Object::Dictionary(resources));
+    Ok(())
+}
+
+/// Stellt einen Inhaltsstrom an den Anfang der Seite (zeichnet also zuunterst).
+fn prepend_content(doc: &mut Document, page_id: ObjectId, content: Vec<u8>) -> Result<(), String> {
+    let existing: Vec<Object> = doc
+        .get_page_contents(page_id)
+        .into_iter()
+        .map(Object::Reference)
+        .collect();
+    let id = doc.add_object(Object::Stream(Stream::new(Dictionary::new(), content)));
+    let mut contents = vec![Object::Reference(id)];
+    contents.extend(existing);
+    let page = doc
+        .get_object_mut(page_id)
+        .and_then(Object::as_dict_mut)
+        .map_err(|e| e.to_string())?;
+    page.set("Contents", Object::Array(contents));
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn apply(m: Matrix, x: f32, y: f32) -> (f32, f32) {
+        (m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5])
+    }
+
+    fn close(a: (f32, f32), b: (f32, f32)) -> bool {
+        (a.0 - b.0).abs() < 1e-3 && (a.1 - b.1).abs() < 1e-3
+    }
+
+    #[test]
+    fn test_placement_matrix() {
+        // Querformat-Folie 800 × 600 ohne Drehung in ein 400 × 300-Rechteck bei (10, 20)
+        let m = placement_matrix([0.0, 0.0, 800.0, 600.0], 0, [10.0, 20.0, 400.0, 300.0]);
+        assert!(close(apply(m, 0.0, 0.0), (10.0, 20.0)));
+        assert!(close(apply(m, 800.0, 600.0), (410.0, 320.0)));
+
+        // Verschobene MediaBox
+        let m = placement_matrix([100.0, 50.0, 300.0, 150.0], 0, [0.0, 0.0, 200.0, 100.0]);
+        assert!(close(apply(m, 100.0, 50.0), (0.0, 0.0)));
+
+        // Um 90° gedrehte Hochformatseite (200 × 400) erscheint quer (400 × 200):
+        // die linke untere Ecke landet links oben
+        let m = placement_matrix([0.0, 0.0, 200.0, 400.0], 90, [0.0, 0.0, 400.0, 200.0]);
+        assert!(close(apply(m, 0.0, 0.0), (0.0, 200.0)));
+        assert!(close(apply(m, 200.0, 0.0), (0.0, 0.0)));
+        assert!(close(apply(m, 0.0, 400.0), (400.0, 200.0)));
+
+        // 180° und 270° (= -90°)
+        let m = placement_matrix([0.0, 0.0, 200.0, 400.0], 180, [0.0, 0.0, 200.0, 400.0]);
+        assert!(close(apply(m, 0.0, 0.0), (200.0, 400.0)));
+        let m = placement_matrix([0.0, 0.0, 200.0, 400.0], -90, [0.0, 0.0, 400.0, 200.0]);
+        assert!(close(apply(m, 0.0, 0.0), (400.0, 0.0)));
+    }
+
+    #[test]
+    fn test_apply_underlays_embeds_source_pages() {
+        let source = crate::pdf_doc::tests::sample_pdf(&[(842.0, 595.0, 0), (595.0, 842.0, 0)]);
+        let target = crate::pdf_doc::tests::sample_pdf(&[(595.0, 842.0, 0), (595.0, 842.0, 0)]);
+        let sources = HashMap::from([("folien".to_string(), source)]);
+        let underlays = vec![
+            Underlay {
+                target_page: 0,
+                source: "folien".into(),
+                source_page: 0,
+                rect: [0.0, 421.0, 595.0, 421.0],
+            },
+            Underlay {
+                target_page: 1,
+                source: "folien".into(),
+                source_page: 5,
+                rect: [0.0, 0.0, 595.0, 842.0],
+            },
+            Underlay {
+                target_page: 1,
+                source: "fehlt".into(),
+                source_page: 0,
+                rect: [0.0, 0.0, 595.0, 842.0],
+            },
+        ];
+        let (bytes, failed) = apply_underlays(&target, &underlays, &sources).unwrap();
+        // Fehlende Quellseite und fehlendes PDF werden gemeldet, der Rest klappt
+        assert_eq!(failed.len(), 2);
+
+        let doc = Document::load_mem(&bytes).unwrap();
+        let pages: Vec<ObjectId> = doc.get_pages().into_values().collect();
+        assert_eq!(
+            pages.len(),
+            2,
+            "Quellseiten dürfen nicht als eigene Seiten auftauchen"
+        );
+        let first = doc.get_page_content(pages[0]).unwrap();
+        let text = String::from_utf8_lossy(&first);
+        assert!(
+            text.starts_with("q "),
+            "Unterlage muss zuerst gezeichnet werden: {text}"
+        );
+        assert!(text.contains("Do Q"));
+        // Ursprünglicher Seiteninhalt bleibt erhalten
+        assert!(text.contains("re f"));
+
+        // Form-XObject mit dem Inhalt der Folie ist in den Ressourcen eingetragen
+        let page = doc.get_dictionary(pages[0]).unwrap();
+        let resources = page.get(b"Resources").unwrap().as_dict().unwrap();
+        let xobjects = resources.get(b"XObject").unwrap().as_dict().unwrap();
+        let (_, form_ref) = xobjects.iter().next().unwrap();
+        let form = doc
+            .get_object(form_ref.as_reference().unwrap())
+            .unwrap()
+            .as_stream()
+            .unwrap();
+        assert_eq!(
+            form.dict.get(b"Subtype").unwrap().as_name().unwrap(),
+            b"Form"
+        );
+        assert!(String::from_utf8_lossy(&form.content).contains("1 0 0 rg"));
+    }
+}

src/platform.rs

@@ -0,0 +1,96 @@
+//! Erkennung der Laufzeitumgebung und Wahl des Anzeigesystems (X11 oder Wayland).
+//!
+//! Unter WSL (WSLg) trennt der Wayland-Compositor die Verbindung, sobald die App ein Bild
+//! über Vulkan übergibt ("Connection reset by peer"). Über X11 (Xwayland) läuft sie stabil,
+//! daher wird unter WSL standardmäßig X11 verwendet. `INK_NOTES_DISPLAY=x11|wayland`
+//! übersteuert die Wahl.
+
+/// Anzeigesystem, mit dem die Ereignisschleife erzeugt wird.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DisplayBackend {
+    /// Automatische Wahl von winit (Wayland, falls verfügbar, sonst X11)
+    Automatic,
+    X11,
+    Wayland,
+}
+
+/// Wählt das Anzeigesystem.
+///
+/// - `override_value`: Inhalt von `INK_NOTES_DISPLAY` (`x11` oder `wayland`, sonst ignoriert)
+/// - `is_wsl`: läuft unter WSL
+/// - `has_x11_display`: `DISPLAY` ist gesetzt (X11/Xwayland erreichbar)
+pub fn choose_display_backend(
+    override_value: Option<&str>,
+    is_wsl: bool,
+    has_x11_display: bool,
+) -> DisplayBackend {
+    match override_value
+        .map(|v| v.trim().to_ascii_lowercase())
+        .as_deref()
+    {
+        Some("x11") => return DisplayBackend::X11,
+        Some("wayland") => return DisplayBackend::Wayland,
+        _ => {}
+    }
+    if is_wsl && has_x11_display {
+        DisplayBackend::X11
+    } else {
+        DisplayBackend::Automatic
+    }
+}
+
+/// Läuft das Programm unter WSL (Windows-Subsystem für Linux)?
+pub fn is_wsl() -> bool {
+    if std::env::var_os("WSL_DISTRO_NAME").is_some() || std::env::var_os("WSL_INTEROP").is_some() {
+        return true;
+    }
+    std::fs::read_to_string("/proc/sys/kernel/osrelease")
+        .map(|release| release.to_ascii_lowercase().contains("microsoft"))
+        .unwrap_or(false)
+}
+
+/// Wahl anhand der aktuellen Umgebung.
+pub fn display_backend_from_env() -> DisplayBackend {
+    choose_display_backend(
+        std::env::var("INK_NOTES_DISPLAY").ok().as_deref(),
+        is_wsl(),
+        std::env::var_os("DISPLAY").is_some_and(|d| !d.is_empty()),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_choose_display_backend() {
+        // WSL mit X11-Display: X11 (Wayland unter WSLg bricht ab)
+        assert_eq!(
+            choose_display_backend(None, true, true),
+            DisplayBackend::X11
+        );
+        // WSL ohne X11-Display: winit entscheiden lassen
+        assert_eq!(
+            choose_display_backend(None, true, false),
+            DisplayBackend::Automatic
+        );
+        // Natives Linux: winit entscheiden lassen
+        assert_eq!(
+            choose_display_backend(None, false, true),
+            DisplayBackend::Automatic
+        );
+        // Übersteuerung
+        assert_eq!(
+            choose_display_backend(Some("wayland"), true, true),
+            DisplayBackend::Wayland
+        );
+        assert_eq!(
+            choose_display_backend(Some(" X11 "), false, true),
+            DisplayBackend::X11
+        );
+        assert_eq!(
+            choose_display_backend(Some("quatsch"), true, true),
+            DisplayBackend::X11
+        );
+    }
+}

src/selection.rs

@@ -2,8 +2,8 @@
 //!
 //! Stellt transaktionale Manipulationen für einzelne oder mehrere Striche und geometrische Formen bereit.
 
-use std::f32::consts::FRAC_PI_2;
 use glam::Vec2;
+use std::f32::consts::FRAC_PI_2;
 
 use crate::canvas::CanvasState;
 use crate::document::{Aabb, Page, Stroke};
@@ -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,
             };
@@ -144,16 +148,16 @@ impl SelectionState {
 
         // 2. 4 Eck-Skalierungsgriffe testen
         let corners_page = [
-            aabb.min,                              // 0: oben-links
-            Vec2::new(aabb.max.x, aabb.min.y),     // 1: oben-rechts
-            aabb.max,                              // 2: unten-rechts
-            Vec2::new(aabb.min.x, aabb.max.y),     // 3: unten-links
+            aabb.min,                          // 0: oben-links
+            Vec2::new(aabb.max.x, aabb.min.y), // 1: oben-rechts
+            aabb.max,                          // 2: unten-rechts
+            Vec2::new(aabb.min.x, aabb.max.y), // 3: unten-links
         ];
         let fixed_corners_page = [
-            aabb.max,                              // gegenüber 0 -> unten-rechts
-            Vec2::new(aabb.min.x, aabb.max.y),     // gegenüber 1 -> unten-links
-            aabb.min,                              // gegenüber 2 -> oben-links
-            Vec2::new(aabb.max.x, aabb.min.y),     // gegenüber 3 -> oben-rechts
+            aabb.max,                          // gegenüber 0 -> unten-rechts
+            Vec2::new(aabb.min.x, aabb.max.y), // gegenüber 1 -> unten-links
+            aabb.min,                          // gegenüber 2 -> oben-links
+            Vec2::new(aabb.max.x, aabb.min.y), // gegenüber 3 -> oben-rechts
         ];
 
         let corners_screen = [
@@ -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],
@@ -239,7 +243,12 @@ impl SelectionState {
         if self.selected_ids.is_empty() {
             return false;
         }
-        let mut strokes = page.get_strokes(&self.selected_ids);
+        // Bilder behalten ihre Farben
+        let mut strokes: Vec<_> = page
+            .get_strokes(&self.selected_ids)
+            .into_iter()
+            .filter(|s| !s.is_image())
+            .collect();
         if strokes.is_empty() {
             return false;
         }
@@ -273,6 +282,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,11 +302,17 @@ 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 { start_page, current_page } = selection.drag_mode {
-        let p1 = canvas.page_to_screen(start_page);
-        let p2 = canvas.page_to_screen(current_page);
+    if let DragMode::BoxSelect {
+        start_page,
+        current_page,
+    } = selection.drag_mode
+    {
+        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]);
@@ -299,12 +324,15 @@ 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::Stroke::new(
+                1.5_f32,
+                egui::Color32::from_rgba_unmultiplied(80, 160, 255, 220),
+            ),
         );
         return;
     }
@@ -314,8 +342,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]));
@@ -331,7 +359,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],
@@ -357,7 +385,11 @@ pub fn render_selection_overlay(
 
     for c in corners {
         let handle_rect = egui::Rect::from_center_size(c, egui::vec2(handle_size, handle_size));
-        painter.rect_filled(handle_rect, egui::Rounding::same(1.5_f32), egui::Color32::WHITE);
+        painter.rect_filled(
+            handle_rect,
+            egui::Rounding::same(1.5_f32),
+            egui::Color32::WHITE,
+        );
         painter.rect_stroke(
             handle_rect,
             egui::Rounding::same(1.5_f32),
@@ -369,7 +401,11 @@ pub fn render_selection_overlay(
     let badge_text = format!(
         "{} {} | [R] Drehen [Entf] Löschen",
         selection.count(),
-        if selection.count() == 1 { "Objekt" } else { "Objekte" }
+        if selection.count() == 1 {
+            "Objekt"
+        } else {
+            "Objekte"
+        }
     );
     let badge_pos = egui::pos2(rect.center().x, rect.max.y + 16.0);
     painter.text(
@@ -459,11 +495,39 @@ mod tests {
         let orig_pos = page.strokes[0].points[0].position;
         assert!(sel.rotate_selected_90_deg(&mut page));
         let rotated_pos = page.strokes[0].points[0].position;
-        assert!((orig_pos.x - rotated_pos.x).abs() > 0.1 || (orig_pos.y - rotated_pos.y).abs() > 0.1);
+        assert!(
+            (orig_pos.x - rotated_pos.x).abs() > 0.1 || (orig_pos.y - rotated_pos.y).abs() > 0.1
+        );
 
         // Undo rotate
         assert!(page.undo());
         let restored_pos = page.strokes[0].points[0].position;
         assert!((orig_pos.x - restored_pos.x).abs() < 1e-4);
     }
+
+    #[test]
+    fn test_recolor_ignores_images() {
+        let mut page = Page::new(1, PageBackground::Blank);
+        let corners = [
+            Vec2::new(0.0, 0.0),
+            Vec2::new(100.0, 0.0),
+            Vec2::new(100.0, 50.0),
+            Vec2::new(0.0, 50.0),
+        ];
+        page.add_stroke(Stroke::new_image(1, "a.png".into(), corners));
+        let undo_depth = page.history.undo_stack.len();
+
+        let mut sel = SelectionState::new();
+        sel.select_single(1);
+        // Nur ein Bild ausgewählt: nichts umzufärben, kein Undo-Eintrag
+        assert!(!sel.recolor_selected(&mut page, [1.0, 0.0, 0.0, 1.0]));
+        assert_eq!(page.history.undo_stack.len(), undo_depth);
+
+        // Bild und Strich: nur der Strich wird umgefärbt
+        page.add_stroke(make_test_stroke(2, 20.0, 20.0, [0.1, 0.1, 0.1, 1.0]));
+        sel.select_multiple(vec![1, 2]);
+        assert!(sel.recolor_selected(&mut page, [1.0, 0.0, 0.0, 1.0]));
+        assert_eq!(page.strokes[0].color, [1.0, 1.0, 1.0, 1.0]);
+        assert_eq!(page.strokes[1].color, [1.0, 0.0, 0.0, 1.0]);
+    }
 }

src/settings.rs

@@ -0,0 +1,230 @@
+//! 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::background::PaperTheme;
+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,
+}
+
+/// Druckkennlinie des Stifts: passt die sehr unterschiedlichen Druckbereiche verschiedener
+/// Digitizer (Wacom EMR, MPP, …) an das Schreibgefühl an.
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct PressureCurve {
+    /// Exponent der Kennlinie: < 1 weich (schon leichter Druck ergibt kräftige Linien),
+    /// > 1 hart (erst fester Druck ergibt kräftige Linien)
+    pub exponent: f32,
+    /// Rohdruck unterhalb dieser Schwelle zählt als kein Druck (dünnste Linie);
+    /// unterdrückt das Grundrauschen empfindlicher Stifte
+    pub threshold: f32,
+}
+
+impl PressureCurve {
+    pub const EXPONENT_RANGE: std::ops::RangeInclusive<f32> = 0.3..=3.0;
+    pub const THRESHOLD_RANGE: std::ops::RangeInclusive<f32> = 0.0..=0.5;
+
+    /// Rechnet den Rohdruck des Stifts (0–1) in den Druck für die Strichbreite um.
+    pub fn apply(&self, raw: f32) -> f32 {
+        let curve = self.sanitized();
+        if !raw.is_finite() {
+            return 0.0;
+        }
+        let normalized = ((raw - curve.threshold) / (1.0 - curve.threshold)).clamp(0.0, 1.0);
+        normalized.powf(curve.exponent)
+    }
+
+    /// Begrenzt Werte aus einer (evtl. von Hand bearbeiteten) Einstellungsdatei auf den
+    /// gültigen Bereich.
+    pub fn sanitized(&self) -> Self {
+        let default = Self::default();
+        let clamp = |v: f32, range: &std::ops::RangeInclusive<f32>, fallback: f32| {
+            if v.is_finite() {
+                v.clamp(*range.start(), *range.end())
+            } else {
+                fallback
+            }
+        };
+        Self {
+            exponent: clamp(self.exponent, &Self::EXPONENT_RANGE, default.exponent),
+            threshold: clamp(self.threshold, &Self::THRESHOLD_RANGE, default.threshold),
+        }
+    }
+}
+
+impl Default for PressureCurve {
+    fn default() -> Self {
+        Self {
+            exponent: 1.0,
+            threshold: 0.0,
+        }
+    }
+}
+
+/// Benutzereinstellungen der Oberfläche.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct UiSettings {
+    pub sidebar_side: SidebarSide,
+    /// Papierfarbe der Anzeige
+    pub paper_theme: PaperTheme,
+    /// Dunkle Stiftfarben auf dunklem Papier aufhellen
+    pub adapt_ink_colors: bool,
+    /// Druckkennlinie des Stifts
+    pub pressure_curve: PressureCurve,
+}
+
+impl Default for UiSettings {
+    fn default() -> Self {
+        Self {
+            sidebar_side: SidebarSide::default(),
+            paper_theme: PaperTheme::default(),
+            adapt_ink_colors: true,
+            pressure_curve: PressureCurve::default(),
+        }
+    }
+}
+
+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 {
+        let mut settings: 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(),
+        };
+        settings.pressure_curve = settings.pressure_curve.sanitized();
+        settings
+    }
+
+    /// 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,
+            paper_theme: PaperTheme::Black,
+            adapt_ink_colors: false,
+            pressure_curve: PressureCurve {
+                exponent: 1.8,
+                threshold: 0.1,
+            },
+        };
+        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());
+    }
+
+    #[test]
+    fn test_old_settings_file_keeps_new_defaults() {
+        // ui.json aus v0.3.x kennt nur die Seite der Werkzeugleiste
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("ui.json");
+        std::fs::write(&path, br#"{"sidebar_side": "Right"}"#).unwrap();
+        let settings = UiSettings::load_from(&path);
+        assert_eq!(settings.sidebar_side, SidebarSide::Right);
+        assert_eq!(settings.paper_theme, PaperTheme::White);
+        assert!(settings.adapt_ink_colors);
+        assert_eq!(settings.pressure_curve, PressureCurve::default());
+
+        // Unsinnige Werte aus einer von Hand bearbeiteten Datei werden begrenzt
+        std::fs::write(
+            &path,
+            br#"{"pressure_curve": {"exponent": 50.0, "threshold": -3.0}}"#,
+        )
+        .unwrap();
+        let curve = UiSettings::load_from(&path).pressure_curve;
+        assert_eq!(curve.exponent, 3.0);
+        assert_eq!(curve.threshold, 0.0);
+    }
+
+    #[test]
+    fn test_pressure_curve() {
+        // Standard: unverändert
+        let linear = PressureCurve::default();
+        for p in [0.0, 0.25, 0.5, 1.0] {
+            assert!((linear.apply(p) - p).abs() < 1e-6);
+        }
+        // Weich: halber Druck ergibt mehr als halbe Breite, hart: weniger
+        let soft = PressureCurve {
+            exponent: 0.5,
+            threshold: 0.0,
+        };
+        let hard = PressureCurve {
+            exponent: 2.0,
+            threshold: 0.0,
+        };
+        assert!(soft.apply(0.5) > 0.6);
+        assert!(hard.apply(0.5) < 0.3);
+        // Endpunkte bleiben fest
+        for curve in [soft, hard] {
+            assert_eq!(curve.apply(0.0), 0.0);
+            assert!((curve.apply(1.0) - 1.0).abs() < 1e-6);
+        }
+        // Schwelle: darunter kein Druck, darüber auf den vollen Bereich gestreckt
+        let gated = PressureCurve {
+            exponent: 1.0,
+            threshold: 0.2,
+        };
+        assert_eq!(gated.apply(0.15), 0.0);
+        assert!((gated.apply(0.6) - 0.5).abs() < 1e-6);
+        assert!((gated.apply(1.0) - 1.0).abs() < 1e-6);
+        // Monoton steigend
+        let mut last = -1.0;
+        for i in 0..=100 {
+            let v = hard.apply(i as f32 / 100.0);
+            assert!(v >= last);
+            last = v;
+        }
+        // Ungültige Eingaben ergeben nie NaN
+        assert_eq!(linear.apply(f32::NAN), 0.0);
+        assert_eq!(linear.apply(7.0), 1.0);
+    }
+}

src/shader.wgsl

@@ -14,6 +14,8 @@ struct VertexOutput {
 struct CameraUniforms {
     transform_scale: vec2<f32>,
     transform_offset: vec2<f32>,
+    // x: 1.0 = dunkle Tinte für dunkles Papier aufhellen (siehe `adapt_ink_color`)
+    ink_params: vec4<f32>,
 };
 
 @group(0) @binding(0)
@@ -32,3 +34,46 @@ fn vs_main(in: VertexInput) -> VertexOutput {
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     return in.color;
 }
+
+// Striche: bei dunklem Papier wird die HSL-Helligkeit dunkler Farben gespiegelt
+// (L -> 1 - L, Farbton und Sättigung bleiben). Entspricht `background::adapt_ink_color`.
+@fragment
+fn fs_ink(in: VertexOutput) -> @location(0) vec4<f32> {
+    if (camera.ink_params.x < 0.5) {
+        return in.color;
+    }
+    let max_c = max(max(in.color.r, in.color.g), in.color.b);
+    let min_c = min(min(in.color.r, in.color.g), in.color.b);
+    let lift = max(1.0 - max_c - min_c, 0.0);
+    return vec4<f32>(in.color.rgb + vec3<f32>(lift), in.color.a);
+}
+
+// Eingefügte Bilder: texturierte Vierecke unter der Tinte
+struct ImageVertexInput {
+    @location(0) position: vec2<f32>,
+    @location(1) uv: vec2<f32>,
+};
+
+struct ImageVertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+};
+
+@group(1) @binding(0)
+var image_texture: texture_2d<f32>;
+@group(1) @binding(1)
+var image_sampler: sampler;
+
+@vertex
+fn vs_image(in: ImageVertexInput) -> ImageVertexOutput {
+    var out: ImageVertexOutput;
+    let ndc = in.position * camera.transform_scale + camera.transform_offset;
+    out.clip_position = vec4<f32>(ndc, 0.0, 1.0);
+    out.uv = in.uv;
+    return out;
+}
+
+@fragment
+fn fs_image(in: ImageVertexOutput) -> @location(0) vec4<f32> {
+    return textureSample(image_texture, image_sampler, in.uv);
+}

src/spline.rs

@@ -105,6 +105,18 @@ impl Default for SplineConfig {
     }
 }
 
+impl SplineConfig {
+    /// Erzeugt eine Spline-Konfiguration aus der Strichbreite in internen Einheiten (10 Einheiten = 1 mm).
+    pub fn from_width_units(width_units: f32) -> Self {
+        let base_radius = (width_units / 2.0).max(0.25);
+        Self {
+            min_radius: (base_radius * 0.5).max(0.15),
+            max_radius: (base_radius * 1.5).max(0.35),
+            samples_per_segment: 16,
+        }
+    }
+}
+
 /// Berechnet den druckabhängigen Radius r(p) = min_r + p * (max_r - min_r).
 pub fn calculate_radius(pressure: f32, min_radius: f32, max_radius: f32) -> f32 {
     let p = pressure.clamp(0.0, 1.0);
@@ -355,11 +367,11 @@ fn rdp_mark(positions: &[glam::Vec2], start: usize, end: usize, epsilon: f32, ke
     let mut max_dist = 0.0_f32;
     let mut max_idx = start;
 
-    for i in (start + 1)..end {
-        let dist = point_to_segment_distance(positions[i], a, b);
+    for (offset, &pos) in positions[(start + 1)..end].iter().enumerate() {
+        let dist = point_to_segment_distance(pos, a, b);
         if dist > max_dist {
             max_dist = dist;
-            max_idx = i;
+            max_idx = start + 1 + offset;
         }
     }
 
@@ -418,10 +430,7 @@ pub fn detect_corners(samples: &[StylusSample], threshold_deg: f32) -> Vec<usize
 }
 
 /// Tastet einen zusammenhängenden, glatten Teilabschnitt (Run) zwischen Ecken ab.
-fn sample_smooth_run(
-    control_points: &[ControlPoint],
-    config: &SplineConfig,
-) -> Vec<SplineSample> {
+fn sample_smooth_run(control_points: &[ControlPoint], config: &SplineConfig) -> Vec<SplineSample> {
     match control_points.len() {
         0 => Vec::new(),
         1 => {
@@ -621,7 +630,12 @@ pub fn generate_finalized_triangle_strip(
 /// 3. Ramer-Douglas-Peucker (RDP) Dezimierung (Toleranz ca. 0.05 bis 0.1 mm)
 /// 4. Generierung der finalen Triangle-Strips mit runden Kappen an Start und Ende.
 pub fn finalize_stroke(raw_samples: &[StylusSample]) -> Stroke {
-    finalize_stroke_with_config(0, raw_samples, [0.0, 0.0, 0.0, 1.0], &SplineConfig::default())
+    finalize_stroke_with_config(
+        0,
+        raw_samples,
+        [0.0, 0.0, 0.0, 1.0],
+        &SplineConfig::default(),
+    )
 }
 
 /// Vollständige Finalisierung mit konfigurierbarer Stroke-ID, Farbe und SplineConfig.
@@ -651,7 +665,10 @@ pub fn finalize_stroke_with_config(
         .map(|v| InkVertex::new(v.position[0], v.position[1], color))
         .collect();
 
-    Stroke::new(stroke_id, decimated, ink_vertices, color)
+    let mut stroke = Stroke::new(stroke_id, decimated, ink_vertices, color);
+    stroke.width = config.min_radius + config.max_radius;
+    stroke.finalized = true;
+    stroke
 }
 
 #[cfg(test)]
@@ -808,9 +825,10 @@ mod tests {
         assert!(!stroke.vertices.is_empty());
 
         // 2. Der Eckpunkt (100.0, 0.0) muss in den Strichpunkten erhalten bleiben
-        let corner_found = stroke.points.iter().any(|s| {
-            (s.position.x - 100.0).abs() < 1e-3 && (s.position.y - 0.0).abs() < 1e-3
-        });
+        let corner_found = stroke
+            .points
+            .iter()
+            .any(|s| (s.position.x - 100.0).abs() < 1e-3 && (s.position.y - 0.0).abs() < 1e-3);
         assert!(
             corner_found,
             "Eckpunkt (100.0, 0.0) muss in den finalen Strichpunkten erhalten bleiben!"
@@ -837,7 +855,11 @@ mod tests {
 
         // 4. Ecken-Erkennung prüft den 90°-Winkel (> 65 Grad)
         let corners = detect_corners(&stroke.points, CORNER_ANGLE_THRESHOLD_DEG);
-        assert_eq!(corners.len(), 1, "Exakt eine 90-Grad-Ecke muss erkannt werden");
+        assert_eq!(
+            corners.len(),
+            1,
+            "Exakt eine 90-Grad-Ecke muss erkannt werden"
+        );
         let corner_idx = corners[0];
         let corner_pt = stroke.points[corner_idx];
         assert!((corner_pt.position.x - 100.0).abs() < 1e-3);
@@ -847,9 +869,21 @@ mod tests {
     #[test]
     fn test_pressure_smoothing() {
         let samples = vec![
-            StylusSample { position: glam::Vec2::new(0.0, 0.0), pressure: 0.2, timestamp: 0.0 },
-            StylusSample { position: glam::Vec2::new(1.0, 0.0), pressure: 0.8, timestamp: 0.1 },
-            StylusSample { position: glam::Vec2::new(2.0, 0.0), pressure: 0.2, timestamp: 0.2 },
+            StylusSample {
+                position: glam::Vec2::new(0.0, 0.0),
+                pressure: 0.2,
+                timestamp: 0.0,
+            },
+            StylusSample {
+                position: glam::Vec2::new(1.0, 0.0),
+                pressure: 0.8,
+                timestamp: 0.1,
+            },
+            StylusSample {
+                position: glam::Vec2::new(2.0, 0.0),
+                pressure: 0.2,
+                timestamp: 0.2,
+            },
         ];
 
         let smoothed = smooth_pressure(&samples);

src/viewport.rs

@@ -3,8 +3,8 @@
 //! Berechnet die affine Transformation zwischen Bildschirmkoordinaten (Window-Pixel),
 //! virtuellen DIN-A4-Seitenkoordinaten ([0, 2100] x [0, 2970]) und dem GPU-NDC-Raum ([-1, 1]).
 
-use glam::{Mat4, Vec2, Vec4};
 use crate::document::{PageViewport, PAGE_HEIGHT, PAGE_WIDTH};
+use glam::{Mat4, Vec2, Vec4};
 
 /// Minimaler und maximaler Zoomfaktor.
 pub const MIN_ZOOM: f32 = 0.25;
@@ -40,7 +40,12 @@ impl ViewportState {
     }
 
     /// Passt den Pan-Offset um eine Bildschirmverschiebung (in Fensterpixeln) an.
-    pub fn pan_by_screen_delta(&mut self, delta_x: f32, delta_y: f32, page_viewport: &PageViewport) {
+    pub fn pan_by_screen_delta(
+        &mut self,
+        delta_x: f32,
+        delta_y: f32,
+        page_viewport: &PageViewport,
+    ) {
         let base_scale = page_viewport.page_width / PAGE_WIDTH;
         if base_scale * self.zoom > 1e-6 {
             self.pan_offset[0] += delta_x / (base_scale * self.zoom);
@@ -122,10 +127,7 @@ impl ViewportState {
         page_viewport: &PageViewport,
     ) -> Vec2 {
         let pt = self.screen_to_page_unclamped(screen_x, screen_y, page_viewport);
-        Vec2::new(
-            pt.x.clamp(0.0, PAGE_WIDTH),
-            pt.y.clamp(0.0, PAGE_HEIGHT),
-        )
+        Vec2::new(pt.x.clamp(0.0, PAGE_WIDTH), pt.y.clamp(0.0, PAGE_HEIGHT))
     }
 
     /// Transformiert einen DIN-A4-Seitenpunkt in Fenster-Pixelkoordinaten.
@@ -244,4 +246,40 @@ mod tests {
         assert!((offset1[0] - offset2[0]).abs() < 1e-5);
         assert!((offset1[1] - offset2[1]).abs() < 1e-5);
     }
+
+    #[test]
+    fn test_pinch_to_zoom_math() {
+        let mut vp = ViewportState::new();
+        let page_vp = PageViewport::calculate(1920.0, 1080.0, 24.0);
+
+        // Simulation von 2 Fingern:
+        // Finger 1 bei (400, 500), Finger 2 bei (600, 500) -> Distanz: 200, Zentrum: (500, 500)
+        let p1_start = (400.0_f32, 500.0_f32);
+        let p2_start = (600.0_f32, 500.0_f32);
+        let dist_start =
+            ((p2_start.0 - p1_start.0).powi(2) + (p2_start.1 - p1_start.1).powi(2)).sqrt();
+        let center_start = (
+            (p1_start.0 + p2_start.0) * 0.5,
+            (p1_start.1 + p2_start.1) * 0.5,
+        );
+        assert_eq!(dist_start, 200.0);
+        assert_eq!(center_start, (500.0, 500.0));
+
+        // Finger auseinanderziehen und leicht verschieben:
+        // Finger 1 bei (350, 520), Finger 2 bei (650, 520) -> Distanz: 300, Zentrum: (500, 520)
+        let p1_end = (350.0_f32, 520.0_f32);
+        let p2_end = (650.0_f32, 520.0_f32);
+        let dist_end = ((p2_end.0 - p1_end.0).powi(2) + (p2_end.1 - p1_end.1).powi(2)).sqrt();
+        let center_end = ((p1_end.0 + p2_end.0) * 0.5, (p1_end.1 + p2_end.1) * 0.5);
+        assert_eq!(dist_end, 300.0);
+        assert_eq!(center_end, (500.0, 520.0));
+
+        let zoom_factor = dist_end / dist_start; // 1.5x Vergrößerung
+        let pan_delta = (center_end.0 - center_start.0, center_end.1 - center_start.1); // (0, +20)
+
+        vp.pan_by_screen_delta(pan_delta.0, pan_delta.1, &page_vp);
+        vp.zoom_at_cursor([center_end.0, center_end.1], zoom_factor, &page_vp);
+
+        assert!((vp.zoom - 1.5).abs() < 1e-4);
+    }
 }

tests/fixtures/future_v99_manifest.json

@@ -0,0 +1,14 @@
+{
+  "format_version": 99,
+  "id": "future_notebook",
+  "title": "Zukunfts-Notizbuch",
+  "created_at": 1800000000,
+  "modified_at": 1800001000,
+  "current_page_index": 0,
+  "pages": [
+    { "id": 1, "background": "Grid5mm" }
+  ],
+  "page_ids": [1],
+  "next_stroke_id": 10,
+  "next_page_id": 2
+}

tests/fixtures/future_v99_page_1.json

@@ -0,0 +1,6 @@
+{
+  "format_version": 99,
+  "id": 1,
+  "background": "Blank",
+  "strokes": []
+}

tests/fixtures/legacy_v0_manifest.json

@@ -0,0 +1,10 @@
+{
+  "id": "legacy_notebook",
+  "title": "Legacy Notizbuch v0",
+  "created_at": 1700000000,
+  "modified_at": 1700001000,
+  "current_page_index": 0,
+  "page_ids": [1],
+  "next_stroke_id": 5,
+  "next_page_id": 2
+}

tests/fixtures/legacy_v0_page_1.json

@@ -0,0 +1,14 @@
+{
+  "id": 1,
+  "background": "DotGrid",
+  "strokes": [
+    {
+      "id": 1,
+      "color": [0.1, 0.2, 0.3, 1.0],
+      "samples": [
+        { "x": 100.0, "y": 200.0, "p": 0.5, "t": 1.0 },
+        { "x": 110.0, "y": 210.0, "p": 0.6, "t": 1.1 }
+      ]
+    }
+  ]
+}

tests/fixtures/unknown_fields_page_1.json

@@ -0,0 +1,11 @@
+{
+  "format_version": 1,
+  "id": 1,
+  "background": "Lined",
+  "strokes": [],
+  "unknown_experimental_feature": {
+    "nested_data": [1, 2, 3],
+    "author": "Antigravity"
+  },
+  "random_future_flag": true
+}