chore(release): bump version to 0.3.7

Ellipsen- und Pfeilerkennung, spitze Pfeilspitzen, Dateiformat-Version 3.

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

.gitea/workflows/release.yaml

@@ -38,15 +38,21 @@ jobs:
             squashfs-tools \
             dpkg-dev \
             curl \
-            minisign \
             python3
 
       - name: Setup Rust Toolchain
         uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
         with:
           toolchain: stable
+          # Die Action installiert mit --profile minimal; ohne diese Komponenten
+          # schlagen cargo fmt und cargo clippy in den Quality Gates sofort fehl
+          components: rustfmt, clippy
           cache: true
 
+      - name: Install rsign2 (Release-Signatur)
+        # RUSTFLAGS leeren: die Toolchain-Action setzt -D warnings, das soll nicht für rsign2 gelten
+        run: RUSTFLAGS="" cargo install rsign2 --locked --version 0.6.7
+
       - name: Code Quality & Testing (Quality Gates)
         run: |
           cargo fmt --check

Cargo.lock

@@ -682,6 +682,16 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "fs2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "futures-core"
 version = "0.3.34"
@@ -1038,12 +1048,13 @@ dependencies = [
 
 [[package]]
 name = "ink-notes"
-version = "0.1.1"
+version = "0.3.7"
 dependencies = [
  "bytemuck",
  "egui",
  "egui-wgpu",
  "egui-winit",
+ "fs2",
  "glam",
  "minisign-verify",
  "octotablet",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ink-notes"
-version = "0.1.1"
+version = "0.3.7"
 edition = "2021"
 description = "Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux"
 repository = "https://gitea.pansi.eu/harald/ink-notes"
@@ -40,6 +40,7 @@ ureq = { version = "2.10", default-features = false, features = ["tls", "gzip",
 url = "2.5"
 octotablet = "0.1.0"
 minisign-verify = "0.3.0"
+fs2 = "0.4"
 
 [profile.dev]
 opt-level = 1 # Erhöht Rendering-Performance auch im Debug-Modus

README.md

@@ -88,19 +88,19 @@ Ergebnis in `target/`:
 
 ### Release-Signatur einrichten (einmalig)
 
-In-App-Updates werden nur mit gültiger Minisign-Signatur installiert. Einmalig ein Schlüsselpaar erzeugen (ohne Passwort, da es nur als CI-Secret verwendet wird):
+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
-minisign -G -W -p ink-notes.pub -s ink-notes.key
-# oder ohne minisign-Paket, mit dem kompatiblen rsign2 (cargo install rsign2):
 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 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.
+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
 

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/release-notes.md.tmpl

@@ -3,12 +3,20 @@
 Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux (Zorin OS 18 / Ubuntu 24.04).
 
 ### Highlights:
+- **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, Rechtecke, Kreise, Rauten, Polygone & Koordinatensysteme (Draw-and-Hold)
-- **Multi-Dokumenten-Manager**: Unbegrenzte Notizbücher mit atomarem Autosave
-- **In-App Updater**: Automatische Versionsprüfung und sichere Atomar-Aktualisierung via Gitea Releases
+- **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:

scripts/build-release.sh

@@ -30,23 +30,38 @@ echo "=== Berechne SHA256-Prüfsummen in target/${CHECKSUM_FILE} ==="
 cd "${ROOT_DIR}/target"
 sha256sum "${DEB_NAME}" "${APPIMAGE_NAME}" > "${CHECKSUM_FILE}"
 
-# 4. Prüfsummen mit Minisign signieren (Pflicht für In-App-Updates)
+# 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}"
-EMBEDDED_PUBKEY=$(grep -m1 'pub const UPDATE_SIGNING_PUBLIC_KEY' "${ROOT_DIR}/src/updater.rs" | cut -d '"' -f2)
+# 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
-    echo "=== Signiere ${CHECKSUM_FILE} mit Minisign ==="
+    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}"
-    minisign -S -s "${KEY_FILE}" -m "${CHECKSUM_FILE}" -t "ink-notes v${VERSION}"
+    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
-    minisign -V -P "${EMBEDDED_PUBKEY}" -m "${CHECKSUM_FILE}"
+    # 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

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 "=================================================================="

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

@@ -87,13 +87,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
@@ -104,6 +134,8 @@ 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,
+    pub current_tool: crate::document::StrokeTool,
 
     // Statische Hintergrund-Geometrie
     pub paper_buffer: wgpu::Buffer,
@@ -144,23 +176,47 @@ impl CanvasState {
         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
@@ -174,8 +230,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()
@@ -183,20 +238,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,
@@ -364,16 +405,22 @@ impl CanvasState {
 
         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,
+            current_tool: crate::document::StrokeTool::Pen,
             paper_buffer,
             background_buffer,
             background_vertex_capacity: Self::INITIAL_BACKGROUND_CAPACITY,
@@ -414,21 +461,54 @@ impl CanvasState {
         );
     }
 
+    /// Setzt die von seitlicher UI belegten Streifen (physische Pixel), damit die Seite
+    /// im freien Bereich zentriert wird. Gibt `true` zurück, wenn sich etwas geändert hat.
+    pub fn set_ui_insets(&mut self, left: f32, right: f32) -> bool {
+        if (self.ui_inset_left - left).abs() < 0.5 && (self.ui_inset_right - right).abs() < 0.5 {
+            return false;
+        }
+        self.ui_inset_left = left;
+        self.ui_inset_right = right;
+        self.recalculate_viewport();
+        true
+    }
+
+    fn recalculate_viewport(&mut self) {
+        self.viewport = PageViewport::calculate_with_insets(
+            self.size.width as f32,
+            self.size.height as f32,
+            Self::VIEWPORT_MARGIN,
+            self.ui_inset_left,
+            self.ui_inset_right,
+        );
+        self.update_uniforms();
+    }
+
     /// Passt die Surface und Projektionsmatrizen an eine neue Fenstergröße an.
     pub fn resize(&mut self, new_size: PhysicalSize<u32>) {
         if new_size.width > 0 && new_size.height > 0 {
             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();
         }
     }
 
@@ -502,10 +582,14 @@ 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 das aktive Zeichenwerkzeug für den Stift.
+    pub fn set_tool(&mut self, tool: crate::document::StrokeTool) {
+        self.current_tool = tool;
     }
 
     /// Setzt den Seitenhintergrund und aktualisiert bei Bedarf den Vertex-Puffer.
@@ -643,6 +727,10 @@ impl CanvasState {
             self.current_ink_color,
             &self.spline_config,
         );
+        let mut stroke = stroke;
+        stroke.tool = self.current_tool;
+        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();
@@ -825,6 +913,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;

src/document.rs

@@ -103,6 +103,16 @@ pub fn point_to_segment_distance(p: glam::Vec2, a: glam::Vec2, b: glam::Vec2) ->
     (p - projection).length()
 }
 
+/// Das Werkzeug, mit dem ein Strich gezeichnet wurde.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum StrokeTool {
+    #[default]
+    Pen,
+    Highlighter,
+    Shape,
+}
+
 /// Ein einzelner Vektor-Strich auf einer Seite.
 #[derive(Debug, Clone, PartialEq)]
 pub struct Stroke {
@@ -112,6 +122,9 @@ pub struct Stroke {
     pub aabb: Aabb,
     pub color: [f32; 4],
     pub shape: Option<crate::geometry::RecognizedShape>,
+    pub tool: StrokeTool,
+    pub width: f32,
+    pub finalized: bool,
 }
 
 impl Stroke {
@@ -141,6 +154,9 @@ impl Stroke {
             aabb,
             color,
             shape: None,
+            tool: StrokeTool::Pen,
+            width: 5.0,
+            finalized: true,
         }
     }
 
@@ -157,6 +173,22 @@ impl Stroke {
     /// Verknüpft diesen Strich mit einer mathematisch erkannten Form.
     pub fn with_shape(mut self, shape: crate::geometry::RecognizedShape) -> Self {
         self.shape = Some(shape);
+        self.tool = StrokeTool::Shape;
+        self
+    }
+
+    pub fn with_tool(mut self, tool: StrokeTool) -> Self {
+        self.tool = tool;
+        self
+    }
+
+    pub fn with_width(mut self, width: f32) -> Self {
+        self.width = width;
+        self
+    }
+
+    pub fn with_finalized(mut self, finalized: bool) -> Self {
+        self.finalized = finalized;
         self
     }
 
@@ -304,6 +336,22 @@ pub enum PageBackground {
     DotGrid,
 }
 
+/// Persistenzstatus einer Seite zum Schutz vor unbeabsichtigtem Überschreiben bei Ladefehlern.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum PersistState {
+    #[default]
+    Normal,
+    ReadOnlyAfterLoadError,
+}
+
+/// Warnung beim Laden einer Seite (beschädigte Datei oder I/O-Fehler).
+#[derive(Debug, Clone, PartialEq)]
+pub struct PageLoadWarning {
+    pub page_id: u64,
+    pub message: String,
+    pub quarantine_path: Option<std::path::PathBuf>,
+}
+
 /// Eine einzelne Notizbuchseite mit Strichen, Hintergrund und gecachten Meshes.
 #[derive(Debug, Clone)]
 pub struct Page {
@@ -314,9 +362,7 @@ pub struct Page {
     pub stroke_ranges: Vec<Range<u32>>,
     pub is_dirty: bool,
     pub is_loaded: bool,
-    /// Laden von der Festplatte ist fehlgeschlagen; die Seite ist ein leerer Ersatz und
-    /// darf niemals gespeichert werden, damit die Originaldatei nicht überschrieben wird.
-    pub load_failed: bool,
+    pub persist: PersistState,
     pub history: HistoryStack,
 }
 
@@ -330,7 +376,7 @@ impl Page {
             stroke_ranges: Vec::new(),
             is_dirty: false,
             is_loaded: true,
-            load_failed: false,
+            persist: PersistState::Normal,
             history: HistoryStack::new(),
         }
     }
@@ -345,11 +391,19 @@ impl Page {
             stroke_ranges: Vec::new(),
             is_dirty: false,
             is_loaded: false,
-            load_failed: false,
+            persist: PersistState::Normal,
             history: HistoryStack::new(),
         }
     }
 
+    pub fn is_readonly(&self) -> bool {
+        self.persist == PersistState::ReadOnlyAfterLoadError
+    }
+
+    pub fn unlock_after_load_error(&mut self) {
+        self.persist = PersistState::Normal;
+    }
+
     /// Fügt einen neuen Strich hinzu und registriert ihn im History-Stack.
     pub fn add_stroke(&mut self, stroke: Stroke) {
         self.history.push(HistoryAction::AddStroke(stroke.clone()));
@@ -592,6 +646,7 @@ pub struct Notebook {
     pub current_page_index: usize,
     pub next_stroke_id: u64,
     pub next_page_id: u64,
+    pub load_warnings: std::collections::HashMap<u64, PageLoadWarning>,
 }
 
 impl Notebook {
@@ -601,6 +656,7 @@ impl Notebook {
             current_page_index: 0,
             next_stroke_id: 1,
             next_page_id: 1,
+            load_warnings: std::collections::HashMap::new(),
         };
         // Erste Standardseite anlegen (5mm Grid)
         nb.add_page(PageBackground::Grid5mm);
@@ -619,6 +675,7 @@ impl Notebook {
             current_page_index,
             next_stroke_id,
             next_page_id,
+            load_warnings: std::collections::HashMap::new(),
         };
         if nb.pages.is_empty() {
             nb.add_page(PageBackground::Grid5mm);
@@ -715,7 +772,21 @@ pub struct PageViewport {
 impl PageViewport {
     /// Berechnet die zentrierte DIN-A4-Projektionsfläche unter Beibehaltung des 210x297-Seitenverhältnisses.
     pub fn calculate(window_width: f32, window_height: f32, margin: f32) -> Self {
-        let avail_w = (window_width - 2.0 * margin).max(10.0);
+        Self::calculate_with_insets(window_width, window_height, margin, 0.0, 0.0)
+    }
+
+    /// Wie [`Self::calculate`], aber ohne die von seitlicher UI (z. B. Werkzeugleiste)
+    /// belegten Streifen links/rechts: Die Seite wird im verbleibenden Bereich zentriert.
+    pub fn calculate_with_insets(
+        window_width: f32,
+        window_height: f32,
+        margin: f32,
+        inset_left: f32,
+        inset_right: f32,
+    ) -> Self {
+        let inset_left = inset_left.clamp(0.0, window_width * 0.5);
+        let inset_right = inset_right.clamp(0.0, window_width * 0.5);
+        let avail_w = (window_width - inset_left - inset_right - 2.0 * margin).max(10.0);
         let avail_h = (window_height - 2.0 * margin).max(10.0);
 
         let window_ratio = avail_w / avail_h;
@@ -733,7 +804,7 @@ impl PageViewport {
             (w, h)
         };
 
-        let page_x = (window_width - page_w) / 2.0;
+        let page_x = inset_left + (window_width - inset_left - inset_right - page_w) / 2.0;
         let page_y = (window_height - page_h) / 2.0;
 
         Self {
@@ -874,6 +945,25 @@ mod tests {
         assert_eq!(nb.current_page_index, 0);
     }
 
+    #[test]
+    fn test_viewport_insets_center_page_in_free_area() {
+        // Breites Fenster: Seite wird durch die Höhe begrenzt und im freien Bereich zentriert
+        let plain = PageViewport::calculate(1600.0, 900.0, 20.0);
+        let inset = PageViewport::calculate_with_insets(1600.0, 900.0, 20.0, 120.0, 0.0);
+        assert!((inset.page_width - plain.page_width).abs() < 0.01);
+        let free_center = 120.0 + (1600.0 - 120.0) / 2.0;
+        assert!((inset.page_x + inset.page_width / 2.0 - free_center).abs() < 0.01);
+
+        // Hohes Fenster: Breite begrenzt, Seite wird schmaler und bleibt rechts der Leiste
+        let narrow = PageViewport::calculate_with_insets(600.0, 1200.0, 20.0, 100.0, 0.0);
+        assert!(narrow.page_x >= 100.0 + 20.0 - 0.01);
+        assert!(narrow.page_x + narrow.page_width <= 600.0 - 20.0 + 0.01);
+
+        // Leiste rechts
+        let right = PageViewport::calculate_with_insets(600.0, 1200.0, 20.0, 0.0, 100.0);
+        assert!(right.page_x + right.page_width <= 500.0 - 20.0 + 0.01);
+    }
+
     #[test]
     fn test_page_viewport_projection() {
         let vp = PageViewport::calculate(1600.0, 900.0, 20.0);

src/export.rs

@@ -140,11 +140,9 @@ pub fn generate_pdf_document(
         return Err("Notizbuch enthält keine Seiten".into());
     }
     // Nicht geladene Seiten würden sonst stillschweigend als leere Seiten exportiert
-    if let Some(page) = notebook
-        .pages
-        .iter()
-        .find(|p| !p.is_loaded || p.load_failed)
-    {
+    if let Some(page) = notebook.pages.iter().find(|p| {
+        !p.is_loaded || p.persist == crate::document::PersistState::ReadOnlyAfterLoadError
+    }) {
         return Err(format!(
             "Seite {} ist nicht geladen – Export abgebrochen (vorher storage::load_all_pages aufrufen)",
             page.id
@@ -331,6 +329,59 @@ fn render_recognized_shape(
             layer.add_polygon(poly);
         }
 
+        RecognizedShape::Ellipse {
+            center,
+            radius_x,
+            radius_y,
+            rotation,
+        } => {
+            let ring = (0..72)
+                .map(|i| {
+                    let t = i as f32 / 72.0 * std::f32::consts::TAU;
+                    let p =
+                        crate::geometry::ellipse_point(*center, *radius_x, *radius_y, *rotation, t);
+                    let (x, y) = page_to_pdf_mm(p.x, p.y);
+                    (Point::new(Mm(x), Mm(y)), false)
+                })
+                .collect();
+            layer.add_polygon(Polygon {
+                rings: vec![ring],
+                mode: PaintMode::Stroke,
+                winding_order: WindingOrder::NonZero,
+            });
+        }
+
+        RecognizedShape::Arrow { start, end, double } => {
+            // Gleiche Spitzen wie auf dem Bildschirm; der Schaft endet an ihrer Basis
+            const PDF_SHAPE_HALF_WIDTH: f32 = 2.65;
+            let shaft_len = (*end - *start).length();
+            let dir = (*end - *start).normalize_or_zero();
+            let end_head = crate::geometry::arrow_head(*end, dir, PDF_SHAPE_HALF_WIDTH, shaft_len);
+            let start_head =
+                crate::geometry::arrow_head(*start, -dir, PDF_SHAPE_HALF_WIDTH, shaft_len);
+            let line_start = if *double { start_head.0 } else { *start };
+            let to_pdf = |p: glam::Vec2| {
+                let (x, y) = page_to_pdf_mm(p.x, p.y);
+                (Point::new(Mm(x), Mm(y)), false)
+            };
+            layer.add_line(Line {
+                points: vec![to_pdf(line_start), to_pdf(end_head.0)],
+                is_closed: false,
+            });
+            layer.set_fill_color(stroke_color);
+            let mut heads = vec![(*end, end_head)];
+            if *double {
+                heads.push((*start, start_head));
+            }
+            for (tip, (_, left, right)) in heads {
+                layer.add_polygon(Polygon {
+                    rings: vec![vec![to_pdf(tip), to_pdf(left), to_pdf(right)]],
+                    mode: PaintMode::Fill,
+                    winding_order: WindingOrder::NonZero,
+                });
+            }
+        }
+
         RecognizedShape::Rectangle { corners } => {
             let mut ring = Vec::with_capacity(4);
             for c in corners {
@@ -414,76 +465,58 @@ fn render_recognized_shape(
             y_axis_end,
             with_arrows,
         } => {
+            // Gleiche Pfeilspitzen wie auf dem Bildschirm; Achsen enden an der Basis der Spitze
+            // (Linienstärke 1,5 pt ≈ 5,3 Seiteneinheiten, halbe Breite ≈ 2,65)
+            const PDF_SHAPE_HALF_WIDTH: f32 = 2.65;
+            let y_dir = (*y_axis_end - *origin).normalize_or_zero();
+            let x_dir = (*x_axis_end - *origin).normalize_or_zero();
+            let y_arrow = crate::geometry::arrow_head(
+                *y_axis_end,
+                y_dir,
+                PDF_SHAPE_HALF_WIDTH,
+                (*y_axis_end - *origin).length(),
+            );
+            let x_arrow = crate::geometry::arrow_head(
+                *x_axis_end,
+                x_dir,
+                PDF_SHAPE_HALF_WIDTH,
+                (*x_axis_end - *origin).length(),
+            );
+            let (y_line_end, x_line_end) = if *with_arrows {
+                (y_arrow.0, x_arrow.0)
+            } else {
+                (*y_axis_end, *x_axis_end)
+            };
+
             let (ox, oy) = page_to_pdf_mm(origin.x, origin.y);
-            let (xx, xy) = page_to_pdf_mm(x_axis_end.x, x_axis_end.y);
-            let (yx, yy) = page_to_pdf_mm(y_axis_end.x, y_axis_end.y);
-
-            // Achse 1 (Y)
-            let line_y = Line {
-                points: vec![
-                    (Point::new(Mm(ox), Mm(oy)), false),
-                    (Point::new(Mm(yx), Mm(yy)), false),
-                ],
-                is_closed: false,
-            };
-            layer.add_line(line_y);
-
-            // Achse 2 (X)
-            let line_x = Line {
-                points: vec![
-                    (Point::new(Mm(ox), Mm(oy)), false),
-                    (Point::new(Mm(xx), Mm(xy)), false),
-                ],
-                is_closed: false,
-            };
-            layer.add_line(line_x);
+            for end in [y_line_end, x_line_end] {
+                let (ex, ey) = page_to_pdf_mm(end.x, end.y);
+                layer.add_line(Line {
+                    points: vec![
+                        (Point::new(Mm(ox), Mm(oy)), false),
+                        (Point::new(Mm(ex), Mm(ey)), false),
+                    ],
+                    is_closed: false,
+                });
+            }
 
             // Pfeilspitzen als gefüllte Dreiecke
             if *with_arrows {
                 layer.set_fill_color(stroke_color);
-
-                let y_dir = (*y_axis_end - *origin).normalize_or_zero();
-                let arrow_len_page = 25.0;
-                let arrow_w_page = 16.0;
-
-                let base_y = *y_axis_end - y_dir * arrow_len_page;
-                let left_y = base_y + glam::Vec2::new(-y_dir.y, y_dir.x) * (arrow_w_page * 0.5);
-                let right_y = base_y - glam::Vec2::new(-y_dir.y, y_dir.x) * (arrow_w_page * 0.5);
-
-                let (tx, ty) = page_to_pdf_mm(y_axis_end.x, y_axis_end.y);
-                let (lx, ly) = page_to_pdf_mm(left_y.x, left_y.y);
-                let (rx, ry) = page_to_pdf_mm(right_y.x, right_y.y);
-
-                let arrow_poly_y = Polygon {
-                    rings: vec![vec![
-                        (Point::new(Mm(tx), Mm(ty)), false),
-                        (Point::new(Mm(lx), Mm(ly)), false),
-                        (Point::new(Mm(rx), Mm(ry)), false),
-                    ]],
-                    mode: PaintMode::Fill,
-                    winding_order: WindingOrder::NonZero,
-                };
-                layer.add_polygon(arrow_poly_y);
-
-                let x_dir = (*x_axis_end - *origin).normalize_or_zero();
-                let base_x = *x_axis_end - x_dir * arrow_len_page;
-                let left_x = base_x + glam::Vec2::new(-x_dir.y, x_dir.x) * (arrow_w_page * 0.5);
-                let right_x = base_x - glam::Vec2::new(-x_dir.y, x_dir.x) * (arrow_w_page * 0.5);
-
-                let (tx_x, ty_x) = page_to_pdf_mm(x_axis_end.x, x_axis_end.y);
-                let (lx_x, ly_x) = page_to_pdf_mm(left_x.x, left_x.y);
-                let (rx_x, ry_x) = page_to_pdf_mm(right_x.x, right_x.y);
-
-                let arrow_poly_x = Polygon {
-                    rings: vec![vec![
-                        (Point::new(Mm(tx_x), Mm(ty_x)), false),
-                        (Point::new(Mm(lx_x), Mm(ly_x)), false),
-                        (Point::new(Mm(rx_x), Mm(ry_x)), false),
-                    ]],
-                    mode: PaintMode::Fill,
-                    winding_order: WindingOrder::NonZero,
-                };
-                layer.add_polygon(arrow_poly_x);
+                for (tip, (_, left, right)) in [(*y_axis_end, y_arrow), (*x_axis_end, x_arrow)] {
+                    let ring = [tip, left, right]
+                        .iter()
+                        .map(|p| {
+                            let (px, py) = page_to_pdf_mm(p.x, p.y);
+                            (Point::new(Mm(px), Mm(py)), false)
+                        })
+                        .collect();
+                    layer.add_polygon(Polygon {
+                        rings: vec![ring],
+                        mode: PaintMode::Fill,
+                        winding_order: WindingOrder::NonZero,
+                    });
+                }
             }
         }
     }
@@ -840,6 +873,27 @@ mod tests {
         );
         page.add_stroke(coords_stroke);
 
+        let ellipse_stroke = Stroke::new(40, vec![], vec![], [0.1, 0.5, 0.5, 1.0]).with_shape(
+            crate::geometry::RecognizedShape::Ellipse {
+                center: glam::Vec2::new(1400.0, 600.0),
+                radius_x: 300.0,
+                radius_y: 150.0,
+                rotation: 0.4,
+            },
+        );
+        page.add_stroke(ellipse_stroke);
+
+        for (id, double) in [(41, false), (42, true)] {
+            let arrow_stroke = Stroke::new(id, vec![], vec![], [0.2, 0.2, 0.2, 1.0]).with_shape(
+                crate::geometry::RecognizedShape::Arrow {
+                    start: glam::Vec2::new(1200.0, 1800.0 + id as f32 * 40.0),
+                    end: glam::Vec2::new(1800.0, 1800.0 + id as f32 * 40.0),
+                    double,
+                },
+            );
+            page.add_stroke(arrow_stroke);
+        }
+
         let tri_stroke = Stroke::new(5, vec![], vec![], [0.6, 0.2, 0.7, 1.0]).with_shape(
             crate::geometry::RecognizedShape::Triangle {
                 corners: [

src/lib.rs

@@ -8,7 +8,9 @@ pub mod export;
 pub mod filter;
 pub mod geometry;
 pub mod history;
+pub mod platform;
 pub mod selection;
+pub mod settings;
 pub mod spline;
 pub mod storage;
 pub mod ui;

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

@@ -115,12 +115,15 @@ impl SelectionState {
         Page::selection_aabb(&strokes)
     }
 
-    /// Führt Hit-Testing auf die Auswahlgriffe (Drehen, Ecken, Körper) in Bildschirmkoordinaten durch.
+    /// Führt Hit-Testing auf die Auswahlgriffe (Drehen, Ecken, Körper) in Bildschirmkoordinaten
+    /// (physische Pixel) durch. Abstände und Trefferradien sind in logischen Punkten festgelegt
+    /// und werden mit `pixels_per_point` skaliert, damit sie zur gezeichneten Überlagerung passen.
     pub fn hit_test_handles(
         &self,
         page: &Page,
         canvas: &CanvasState,
         screen_pos: Vec2,
+        pixels_per_point: f32,
     ) -> SelectionHandleHit {
         let Some(aabb) = self.get_selection_aabb(page) else {
             return SelectionHandleHit::None;
@@ -134,9 +137,10 @@ impl SelectionState {
         let screen_center = (screen_min + screen_max) * 0.5;
         let page_center = (aabb.min + aabb.max) * 0.5;
 
-        // 1. Drehgriff testen (26 px oberhalb des oberen Randes)
-        let rot_screen = Vec2::new(screen_center.x, screen_min.y - 26.0);
-        if (screen_pos - rot_screen).length() <= 14.0 {
+        // 1. Drehgriff testen (oberhalb des oberen Randes, wie gezeichnet)
+        let ppp = pixels_per_point;
+        let rot_screen = Vec2::new(screen_center.x, screen_min.y - ROTATE_HANDLE_OFFSET * ppp);
+        if (screen_pos - rot_screen).length() <= HANDLE_HIT_RADIUS * ppp {
             return SelectionHandleHit::RotateHandle {
                 center_page: page_center,
             };
@@ -164,7 +168,7 @@ impl SelectionState {
         ];
 
         for i in 0..4 {
-            if (screen_pos - corners_screen[i]).length() <= 12.0 {
+            if (screen_pos - corners_screen[i]).length() <= HANDLE_HIT_RADIUS * ppp {
                 return SelectionHandleHit::CornerHandle {
                     corner_idx: i,
                     fixed_corner_page: fixed_corners_page[i],
@@ -273,6 +277,16 @@ impl SelectionState {
 }
 
 /// Rendert das Auswahl-Overlay (Bounding Box, Ecken, Dreh-Griff, Marquee Box) über egui.
+/// Abstand des Drehgriffs über dem Auswahlrahmen (logische Punkte).
+const ROTATE_HANDLE_OFFSET: f32 = 24.0;
+/// Trefferradius der Griffe (logische Punkte), groß genug für Finger.
+const HANDLE_HIT_RADIUS: f32 = 18.0;
+
+/// Wandelt Fensterpixel (physisch) in egui-Koordinaten (logische Punkte) um.
+fn to_ui(screen: [f32; 2], pixels_per_point: f32) -> egui::Pos2 {
+    egui::pos2(screen[0] / pixels_per_point, screen[1] / pixels_per_point)
+}
+
 pub fn render_selection_overlay(
     ctx: &egui::Context,
     selection: &SelectionState,
@@ -283,6 +297,8 @@ pub fn render_selection_overlay(
         egui::Order::Foreground,
         egui::Id::new("selection_overlay_layer"),
     ));
+    // Fensterpixel sind physisch, egui zeichnet in logischen Punkten
+    let ppp = ctx.pixels_per_point();
 
     // 1. Wenn aktuell ein Auswahlrahmen gezogen wird (Marquee Box)
     if let DragMode::BoxSelect {
@@ -290,8 +306,8 @@ pub fn render_selection_overlay(
         current_page,
     } = selection.drag_mode
     {
-        let p1 = canvas.page_to_screen(start_page);
-        let p2 = canvas.page_to_screen(current_page);
+        let p1 = to_ui(canvas.page_to_screen(start_page), ppp);
+        let p2 = to_ui(canvas.page_to_screen(current_page), ppp);
         let min_x = p1[0].min(p2[0]);
         let min_y = p1[1].min(p2[1]);
         let max_x = p1[0].max(p2[0]);
@@ -303,14 +319,14 @@ pub fn render_selection_overlay(
         painter.rect_filled(
             rect,
             egui::Rounding::same(4.0_f32),
-            egui::Color32::from_rgba_premultiplied(40, 120, 240, 35),
+            egui::Color32::from_rgba_unmultiplied(40, 120, 240, 35),
         );
         painter.rect_stroke(
             rect,
             egui::Rounding::same(4.0_f32),
             egui::Stroke::new(
                 1.5_f32,
-                egui::Color32::from_rgba_premultiplied(80, 160, 255, 220),
+                egui::Color32::from_rgba_unmultiplied(80, 160, 255, 220),
             ),
         );
         return;
@@ -321,8 +337,8 @@ pub fn render_selection_overlay(
         return;
     };
 
-    let p_min = canvas.page_to_screen(aabb.min);
-    let p_max = canvas.page_to_screen(aabb.max);
+    let p_min = to_ui(canvas.page_to_screen(aabb.min), ppp);
+    let p_max = to_ui(canvas.page_to_screen(aabb.max), ppp);
 
     let screen_min = egui::pos2(p_min[0].min(p_max[0]), p_min[1].min(p_max[1]));
     let screen_max = egui::pos2(p_min[0].max(p_max[0]), p_min[1].max(p_max[1]));
@@ -338,7 +354,7 @@ pub fn render_selection_overlay(
 
     // Dreh-Stängel (Stalk) und Drehgriff
     let top_center = egui::pos2(rect.center().x, rect.min.y);
-    let rot_handle = egui::pos2(rect.center().x, rect.min.y - 24.0_f32);
+    let rot_handle = egui::pos2(rect.center().x, rect.min.y - ROTATE_HANDLE_OFFSET);
 
     painter.line_segment(
         [top_center, rot_handle],

src/settings.rs

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

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);
@@ -653,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)]

src/updater.rs

@@ -317,7 +317,8 @@ pub fn verify_checksum(
 /// signiert sein muss. Ist er leer, lehnt diese Version alle In-App-Updates ab.
 /// Erzeugen: `minisign -G -W -p ink-notes.pub -s ink-notes.key`, dann die zweite Zeile
 /// aus `ink-notes.pub` hier eintragen (siehe README, Abschnitt Release-Signatur).
-pub const UPDATE_SIGNING_PUBLIC_KEY: &str = "";
+pub const UPDATE_SIGNING_PUBLIC_KEY: &str =
+    "RWTZqQ0ZDCn+PHTpqgI8NwjtgtkJk5QyJ0FYHWZlCZtABsXBcdPDv9WI";
 
 /// Name des Prüfsummen-Assets eines Releases.
 pub const CHECKSUMS_ASSET_NAME: &str = "SHA256SUMS.txt";

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
+}