Backend-Arbeitsstand: ERP-Sync, Lieferlebenszyklus, Reports + config.toml

Bringt das Backend vom initialen Skeleton auf den aktuellen Arbeitsstand
(Clean Architecture: domain → application → infrastructure → api).

Wesentliche Bereiche:
- ERP-Anbindung (MSSQL-Pull der Touren, Import-Scheduler, Rückschreiben)
- Lieferlebenszyklus: Scan/Hold/Cancel/Complete, Gutschriften, Notizen,
  Bild-Anhänge, Unterschriften, PDF-Lieferreport → DOCUframe
- Stammdaten: Kunden, Artikel, Lager, Zahlungsarten, Services
- Keycloak-JWT-Gate + Fahrer-Provisionierung via Admin-API
- Admin-API-Key-Gate (X-Admin-Api-Key) für Maschinen-Endpunkte

Jüngste Änderungen dieser Session:
- Belegspezifische Kontaktdaten: alle ERP-Adressen (Beleg-/Liefer-/
  Rechnungsadresse, Ansprechpartner, Kundenstamm) mit Telefon/Mobil/
  E-Mail werden gesynct (Migration 0029, MSSQL-Query, TourDetails)
- Konfiguration von .env (envy/dotenvy) auf config.toml (toml/serde)
  umgestellt; Vorlage config.example.toml, Pfad via HOLZLEITNER_CONFIG

Nicht im Repo (per .gitignore): config.toml (Secrets), data/ (Laufzeit-/
Kundendaten), demo.mp4, .claude/, variocontrol-ai/.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

crates/infrastructure/src/report/renderer.rs

@@ -0,0 +1,699 @@
+//! printpdf-Renderer für den Lieferreport.
+//!
+//! Nutzt die eingebaute **Helvetica** (WinAnsi → deutsche Umlaute) — kein
+//! Font-Asset. Einfache, eigene Layout-Engine: Cursor `y` von oben nach unten,
+//! automatischer Seitenumbruch, klippende Tabellen, eingebettete Bilder
+//! (Unterschriften + Foto-Notizen) via roher RGB-Daten.
+
+use printpdf::{
+    BuiltinFont, Color, ColorBits, ColorSpace, Image, ImageFilter, ImageTransform, ImageXObject,
+    IndirectFontRef, Line, Mm, PdfDocument, PdfDocumentReference, PdfLayerReference, Point, Px, Rgb,
+};
+
+use holzleitner_application::dto::DeliveryReportData;
+use holzleitner_application::error::ApplicationError;
+use holzleitner_application::ports::DeliveryReportRenderer;
+
+const PAGE_W: f32 = 210.0;
+const PAGE_H: f32 = 297.0;
+const MARGIN_L: f32 = 15.0;
+const MARGIN_R: f32 = 15.0;
+const MARGIN_TOP: f32 = 15.0;
+const MARGIN_BOTTOM: f32 = 16.0;
+const CONTENT_W: f32 = PAGE_W - MARGIN_L - MARGIN_R; // 180
+
+fn pt2mm(pt: f32) -> f32 {
+    pt * 0.352_778
+}
+/// Grobe Helvetica-Zeichenbreite (≈0.5em) — reicht für Umbruch/Klippen.
+fn char_w(size: f32) -> f32 {
+    pt2mm(size) * 0.5
+}
+/// Geschätzte Breite (mm) der fetten Schlüssel-Spalte inkl. 4mm Luft.
+/// Konservative Obergrenze für Helvetica-Bold (~0.6em → hier 0.66em).
+fn kv_col(key: &str) -> f32 {
+    pt2mm(9.0) * 0.66 * key.chars().count() as f32 + 4.0
+}
+fn money(v: f64) -> String {
+    format!("{:.2} €", v).replace('.', ",")
+}
+fn cents(c: i64) -> String {
+    money(c as f64 / 100.0)
+}
+
+pub struct PdfDeliveryReportRenderer;
+
+struct Pdf {
+    doc: PdfDocumentReference,
+    font: IndirectFontRef,
+    bold: IndirectFontRef,
+    layer: PdfLayerReference,
+    y: f32,
+}
+
+impl Pdf {
+    fn new(title: &str) -> Result<Self, ApplicationError> {
+        let (doc, page, layer) = PdfDocument::new(title, Mm(PAGE_W), Mm(PAGE_H), "Layer 1");
+        let font = doc
+            .add_builtin_font(BuiltinFont::Helvetica)
+            .map_err(ext)?;
+        let bold = doc
+            .add_builtin_font(BuiltinFont::HelveticaBold)
+            .map_err(ext)?;
+        let layer = doc.get_page(page).get_layer(layer);
+        Ok(Self {
+            doc,
+            font,
+            bold,
+            layer,
+            y: PAGE_H - MARGIN_TOP,
+        })
+    }
+
+    fn new_page(&mut self) {
+        let (page, layer) = self.doc.add_page(Mm(PAGE_W), Mm(PAGE_H), "Layer 1");
+        self.layer = self.doc.get_page(page).get_layer(layer);
+        self.y = PAGE_H - MARGIN_TOP;
+    }
+
+    fn ensure(&mut self, needed: f32) {
+        if self.y - needed < MARGIN_BOTTOM {
+            self.new_page();
+        }
+    }
+
+    /// Schreibt eine Zeile ab x (mm von links innerhalb des Inhalts).
+    fn put(&mut self, text: &str, size: f32, bold: bool, x: f32, baseline_y: f32) {
+        let font = if bold { &self.bold } else { &self.font };
+        self.layer
+            .use_text(text, size, Mm(MARGIN_L + x), Mm(baseline_y), font);
+    }
+
+    fn max_chars(&self, width: f32, size: f32) -> usize {
+        ((width / char_w(size)).floor() as usize).max(1)
+    }
+
+    fn clip(&self, text: &str, width: f32, size: f32) -> String {
+        let max = self.max_chars(width, size);
+        if text.chars().count() <= max {
+            text.to_string()
+        } else if max <= 1 {
+            "…".to_string()
+        } else {
+            let truncated: String = text.chars().take(max - 1).collect();
+            format!("{truncated}…")
+        }
+    }
+
+    /// Mehrzeiliger, umbrechender Text. `indent` in mm.
+    fn text(&mut self, text: &str, size: f32, bold: bool, indent: f32) {
+        let avail = CONTENT_W - indent;
+        let max = self.max_chars(avail, size);
+        for raw_line in text.split('\n') {
+            if raw_line.is_empty() {
+                self.y -= pt2mm(size) * 1.3;
+                continue;
+            }
+            let mut current = String::new();
+            for word in raw_line.split_whitespace() {
+                let candidate = if current.is_empty() {
+                    word.to_string()
+                } else {
+                    format!("{current} {word}")
+                };
+                if candidate.chars().count() > max && !current.is_empty() {
+                    self.write_line(&current, size, bold, indent);
+                    current = word.to_string();
+                } else {
+                    current = candidate;
+                }
+            }
+            if !current.is_empty() {
+                self.write_line(&current, size, bold, indent);
+            }
+        }
+    }
+
+    fn write_line(&mut self, text: &str, size: f32, bold: bool, indent: f32) {
+        let lh = pt2mm(size) * 1.35;
+        self.ensure(lh);
+        let baseline = self.y - pt2mm(size);
+        self.put(text, size, bold, indent, baseline);
+        self.y -= lh;
+    }
+
+    fn gap(&mut self, mm: f32) {
+        self.y -= mm;
+    }
+
+    fn title(&mut self, text: &str) {
+        self.write_line(text, 18.0, true, 0.0);
+        self.gap(2.0);
+    }
+
+    fn heading(&mut self, text: &str) {
+        self.gap(4.0);
+        self.ensure(8.0);
+        self.write_line(text, 12.0, true, 0.0);
+        self.gap(1.0);
+    }
+
+    fn kv(&mut self, key: &str, value: &str) {
+        // Wert-Spalte normal bei 42mm; ist der (fette) Schlüssel breiter,
+        // wird der Wert nach rechts geschoben, damit nichts überlappt.
+        let val_x = 42.0_f32.max(kv_col(key));
+        self.kv_at(key, value, val_x);
+    }
+
+    /// Wie `kv`, aber mit fest vorgegebener Wert-Spalte `val_x` (mm) — für
+    /// bündig ausgerichtete Blöcke, in denen alle Werte an derselben Stelle
+    /// beginnen (Spaltenbreite = breitester Schlüssel des Blocks).
+    fn kv_at(&mut self, key: &str, value: &str, val_x: f32) {
+        // Key in der ersten Spalte (fett), Wert daneben.
+        let lh = pt2mm(9.0) * 1.35;
+        self.ensure(lh);
+        let baseline = self.y - pt2mm(9.0);
+        self.put(key, 9.0, true, 0.0, baseline);
+        let val = self.clip(value, CONTENT_W - val_x, 9.0);
+        self.put(&val, 9.0, false, val_x, baseline);
+        self.y -= lh;
+    }
+
+    /// Tabellenzeile: (Text, Spaltenbreite mm, fett). Klippt je Zelle.
+    fn row(&mut self, cells: &[(String, f32, bool)], size: f32) {
+        let lh = pt2mm(size) * 1.5;
+        self.ensure(lh);
+        let baseline = self.y - pt2mm(size);
+        let mut x = 0.0;
+        for (text, width, bold) in cells {
+            let clipped = self.clip(text, *width - 1.5, size);
+            self.put(&clipped, size, *bold, x, baseline);
+            x += width;
+        }
+        self.y -= lh;
+    }
+
+    /// Bettet ein Bild ein (Bytes → RGB). `max_w`/`max_h` in mm. Bewegt den
+    /// Cursor (für Anhänge/Foto-Notizen im Textfluss).
+    fn image(&mut self, bytes: &[u8], max_w: f32, max_h: f32) {
+        // `max_h` ist die obere Schranke der Zeichenhöhe → konservativ reservieren.
+        self.ensure(max_h + 2.0);
+        match self.draw_image_at(bytes, MARGIN_L, self.y, max_w, max_h) {
+            Some(h) => self.y -= h + 2.0,
+            None => self.text("[Bild konnte nicht gelesen werden]", 8.0, false, 0.0),
+        }
+    }
+
+    /// Zeichnet ein Bild an fester Position (x links, `top_y` Oberkante, mm),
+    /// **ohne** den Cursor zu verändern. Liefert die gezeichnete Höhe in mm
+    /// (oder `None`, wenn das Bild nicht dekodiert werden konnte).
+    fn draw_image_at(&self, bytes: &[u8], x_mm: f32, top_y: f32, max_w: f32, max_h: f32) -> Option<f32> {
+        let dynimg = image::load_from_memory(bytes).ok()?;
+        // Auf eine sinnvolle Maximal-Kantenlänge runterskalieren — ein Report
+        // braucht keine 12-MP-Fotos. Begrenzt die Pixelmenge VOR der Kompression.
+        const MAX_EDGE: u32 = 1600;
+        let dynimg = if dynimg.width().max(dynimg.height()) > MAX_EDGE {
+            dynimg.resize(MAX_EDGE, MAX_EDGE, image::imageops::FilterType::Triangle)
+        } else {
+            dynimg
+        };
+        let rgb = dynimg.to_rgb8();
+        let (w_px, h_px) = (rgb.width(), rgb.height());
+        if w_px == 0 || h_px == 0 {
+            return None;
+        }
+        // JPEG-komprimieren und als DCTDecode-Stream ins PDF legen (statt rohem
+        // RGB) → drastisch kleinere PDFs (12-MP-Foto: 37 MB roh → ~200 KB).
+        let mut jpeg: Vec<u8> = Vec::new();
+        {
+            let mut enc = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut jpeg, 82);
+            enc.encode(rgb.as_raw(), w_px, h_px, image::ExtendedColorType::Rgb8)
+                .ok()?;
+        }
+        // Zielgröße unter Wahrung des Seitenverhältnisses.
+        let aspect = h_px as f32 / w_px as f32;
+        let mut draw_w = max_w;
+        let mut draw_h = draw_w * aspect;
+        if draw_h > max_h {
+            draw_h = max_h;
+            draw_w = draw_h / aspect;
+        }
+        let bottom = top_y - draw_h;
+
+        // Scale relativ zur Default-DPI (300): natürliche Breite in mm.
+        let natural_w_mm = (w_px as f32) / 300.0 * 25.4;
+        let scale = if natural_w_mm > 0.0 {
+            draw_w / natural_w_mm
+        } else {
+            1.0
+        };
+
+        let xobject = ImageXObject {
+            width: Px(w_px as usize),
+            height: Px(h_px as usize),
+            color_space: ColorSpace::Rgb,
+            bits_per_component: ColorBits::Bit8,
+            interpolate: false,
+            image_data: jpeg,
+            image_filter: Some(ImageFilter::DCT),
+            smask: None,
+            clipping_bbox: None,
+        };
+        Image::from(xobject).add_to_layer(
+            self.layer.clone(),
+            ImageTransform {
+                translate_x: Some(Mm(x_mm)),
+                translate_y: Some(Mm(bottom)),
+                scale_x: Some(scale),
+                scale_y: Some(scale),
+                ..Default::default()
+            },
+        );
+        Some(draw_h)
+    }
+
+    /// Zeichnet einen Rechteck-Rahmen (nur Kontur, grau). `bottom_y` = Unterkante.
+    fn rect(&self, x_mm: f32, bottom_y: f32, w: f32, h: f32) {
+        self.layer
+            .set_outline_color(Color::Rgb(Rgb::new(0.6, 0.6, 0.6, None)));
+        self.layer.set_outline_thickness(0.5); // pt
+        let (x0, x1) = (x_mm, x_mm + w);
+        let (y0, y1) = (bottom_y, bottom_y + h);
+        let line = Line {
+            points: vec![
+                (Point::new(Mm(x0), Mm(y0)), false),
+                (Point::new(Mm(x1), Mm(y0)), false),
+                (Point::new(Mm(x1), Mm(y1)), false),
+                (Point::new(Mm(x0), Mm(y1)), false),
+            ],
+            is_closed: true,
+        };
+        self.layer.add_line(line);
+    }
+
+    /// Unterschriftsfeld: Beschriftung + umrahmter Kasten mit dem (kleinen) Bild.
+    fn signature_box(&mut self, label: &str, png: &[u8]) {
+        const BOX_W: f32 = 75.0;
+        const BOX_H: f32 = 22.0;
+        const PAD: f32 = 2.5;
+        let label_lh = pt2mm(9.0) * 1.35;
+        // Beschriftung + Kasten zusammenhalten (kein Umbruch mittendrin).
+        self.ensure(label_lh + BOX_H + 3.0);
+        self.write_line(label, 9.0, true, 0.0);
+        let top = self.y;
+        let bottom = top - BOX_H;
+        self.rect(MARGIN_L, bottom, BOX_W, BOX_H);
+        self.draw_image_at(
+            png,
+            MARGIN_L + PAD,
+            top - PAD,
+            BOX_W - 2.0 * PAD,
+            BOX_H - 2.0 * PAD,
+        );
+        self.y = bottom - 3.0;
+    }
+
+    fn finish(self) -> Result<Vec<u8>, ApplicationError> {
+        self.doc.save_to_bytes().map_err(ext)
+    }
+}
+
+fn ext<E: std::fmt::Display>(e: E) -> ApplicationError {
+    ApplicationError::Repository(format!("pdf: {e}"))
+}
+
+fn dt(d: &chrono::DateTime<chrono::Utc>) -> String {
+    d.format("%d.%m.%Y %H:%M").to_string()
+}
+fn opt(s: &Option<String>) -> &str {
+    s.as_deref().unwrap_or("—")
+}
+
+/// Lesbare Belegart: „VL5 — Lieferschein EH", sonst nur Code/Name, sonst die
+/// nackte ERP-ID („Nr. 24") als Fallback für noch nicht nachsynchronisierte
+/// Altbestände.
+fn belegart_label(d: &DeliveryReportData) -> String {
+    let code = d
+        .belegart_code
+        .as_deref()
+        .map(str::trim)
+        .filter(|s| !s.is_empty());
+    let name = d
+        .belegart_name
+        .as_deref()
+        .map(str::trim)
+        .filter(|s| !s.is_empty());
+    match (code, name) {
+        (Some(c), Some(n)) => format!("{c} — {n}"),
+        (Some(c), None) => c.to_string(),
+        (None, Some(n)) => n.to_string(),
+        (None, None) => format!("Nr. {}", d.belegart_id),
+    }
+}
+
+/// Deutsche Beschriftung des Lieferungs-Status (DB-Werte sind technisch/englisch).
+fn state_de(s: &str) -> &str {
+    match s {
+        "active" => "Aktiv",
+        "held" => "Zurückgestellt",
+        "canceled" => "Storniert",
+        "completed" => "Abgeschlossen",
+        other => other,
+    }
+}
+
+/// Deutsche Beschriftung des Positions-/Scanstatus.
+fn status_de(s: &str) -> &str {
+    match s {
+        "in_progress" => "In Arbeit",
+        "done" => "Erledigt",
+        "held" => "Zurückgestellt",
+        "removed" => "Entfernt",
+        other => other,
+    }
+}
+
+/// Deutsche Beschriftung der Belade-/Scanaktion.
+fn scan_action_de(s: &str) -> &str {
+    match s {
+        "scan" => "Erfasst",
+        "unscan" => "Zurückgesetzt",
+        "hold" => "Zurückgestellt",
+        "unhold" => "Freigegeben",
+        "remove" => "Entfernt",
+        other => other,
+    }
+}
+
+/// Deutsche Beschriftung der Gutschriftaktion.
+fn credit_action_de(s: &str) -> &str {
+    match s {
+        "set" => "Gesetzt",
+        "remove" => "Entfernt",
+        other => other,
+    }
+}
+
+impl DeliveryReportRenderer for PdfDeliveryReportRenderer {
+    fn render(&self, d: &DeliveryReportData) -> Result<Vec<u8>, ApplicationError> {
+        let mut p = Pdf::new(&format!("Lieferbericht {}", d.belegnummer))?;
+
+        // 1. Kopf
+        p.title(&format!("Lieferbericht {}", d.belegnummer));
+        p.kv("Belegnummer", &d.belegnummer);
+        p.kv("Belegart", &belegart_label(d));
+        p.kv("Status", state_de(&d.state));
+        p.kv("Tourdatum", &d.tour_date.format("%d.%m.%Y").to_string());
+        match &d.completion {
+            Some(c) => p.kv("Abgeschlossen", &dt(&c.completed_at)),
+            None => p.kv("Abgeschlossen", "— (nicht abgeschlossen)"),
+        }
+        p.kv("Fahrer", &format!("{} ({})", d.driver_name, d.driver_personalnummer));
+        p.kv("Fahrzeug", opt(&d.car_plate));
+        p.kv("Erstellt am", &dt(&d.generated_at));
+
+        // 2. Kunde & Lieferadresse
+        p.heading("Kunde & Lieferadresse");
+        p.kv("Kunde", &format!("{} (Nr. {})", d.customer_name, d.customer_number));
+        p.kv("Adresse", &d.address);
+        p.kv("Wunschzeit", opt(&d.desired_time));
+        if let Some(sa) = &d.special_agreements {
+            if !sa.trim().is_empty() {
+                p.text(&format!("Sonderwünsche: {sa}"), 9.0, false, 0.0);
+            }
+        }
+        for c in &d.contacts {
+            let line = match &c.detail {
+                Some(det) => format!("Ansprechpartner: {} ({det})", c.name),
+                None => format!("Ansprechpartner: {}", c.name),
+            };
+            p.text(&line, 9.0, false, 0.0);
+        }
+
+        // 3. Positionen
+        p.heading("Positionen");
+        let cols: [(&str, f32); 6] = [
+            ("Artikel", 78.0),
+            ("Soll", 16.0),
+            ("Gel.", 16.0),
+            ("Gutschr.", 22.0),
+            ("Einzel", 26.0),
+            ("Lager", 22.0),
+        ];
+        p.row(
+            &cols.iter().map(|(t, w)| (t.to_string(), *w, true)).collect::<Vec<_>>(),
+            8.0,
+        );
+        let mut warenwert = 0.0_f64;
+        for it in &d.items {
+            warenwert += it.unit_price * it.delivered() as f64;
+            let label = if it.is_component() {
+                format!("  ↳ {} ({})", it.name, it.article_number)
+            } else {
+                format!("{} ({})", it.name, it.article_number)
+            };
+            p.row(
+                &[
+                    (label, 78.0, false),
+                    (it.required_quantity.to_string(), 16.0, false),
+                    (it.delivered().to_string(), 16.0, false),
+                    (it.credited_quantity.to_string(), 22.0, false),
+                    (money(it.unit_price), 26.0, false),
+                    (it.warehouse_code.clone().unwrap_or_default(), 22.0, false),
+                ],
+                8.0,
+            );
+        }
+        // Lager-Legende: Nummer → Name (einmalig, alphabetisch nach Nummer).
+        let mut lager: std::collections::BTreeMap<String, String> = std::collections::BTreeMap::new();
+        for it in &d.items {
+            if let Some(code) = &it.warehouse_code {
+                if !code.trim().is_empty() {
+                    lager
+                        .entry(code.clone())
+                        .or_insert_with(|| it.warehouse_name.clone().unwrap_or_default());
+                }
+            }
+        }
+        if !lager.is_empty() {
+            let legend = lager
+                .iter()
+                .map(|(code, name)| {
+                    if name.trim().is_empty() {
+                        code.clone()
+                    } else {
+                        format!("{code} = {name}")
+                    }
+                })
+                .collect::<Vec<_>>()
+                .join("    ");
+            p.gap(1.0);
+            p.text(&format!("Lager: {legend}"), 7.5, false, 0.0);
+        }
+
+        // 4. Zahlung
+        p.heading("Zahlung");
+        let credit = d.current_credit_cents as f64 / 100.0;
+        let open = (warenwert - d.prepaid_amount - credit).max(0.0);
+        p.kv("Warenwert", &money(warenwert));
+        p.kv("Anzahlung", &money(d.prepaid_amount));
+        p.kv("Gutschrift", &cents(d.current_credit_cents));
+        p.kv("Offener Betrag", &money(open));
+        p.kv("Zahlungsmethode", opt(&d.payment_method));
+        // Inkasso-Bestätigung: nur wenn beim Abschluss tatsächlich kassiert
+        // wurde (Bar/EC bei offenem Betrag). „Auf Rechnung"/voll bezahlt → keine.
+        if let Some(c) = &d.completion {
+            if let Some(collected) = c.collected_amount_cents {
+                p.kv(
+                    "Betrag erhalten",
+                    &format!("Ja — {} (am {})", cents(collected), dt(&c.completed_at)),
+                );
+            }
+        }
+
+        // 5. Dienstleistungen
+        p.heading("Dienstleistungen");
+        if d.services.is_empty() {
+            p.text("— keine —", 9.0, false, 0.0);
+        } else {
+            // Gemeinsame Wert-Spalte = Breite des längsten Dienstleistungs-
+            // Namens (mind. 42mm), damit die zweite Spalte bündig ausgerichtet
+            // ist statt pro Zeile zu springen.
+            let col = d
+                .services
+                .iter()
+                .map(|s| kv_col(&s.name))
+                .fold(42.0_f32, f32::max);
+            for s in &d.services {
+                let val = if let Some(b) = s.bool_value {
+                    if b { "Ja".to_string() } else { "Nein".to_string() }
+                } else if let Some(n) = s.numeric_value {
+                    n.to_string()
+                } else {
+                    "—".to_string()
+                };
+                p.kv_at(&s.name, &val, col);
+            }
+        }
+
+        // 6. Notizen
+        p.heading("Notizen");
+        if d.notes.is_empty() {
+            p.text("— keine —", 9.0, false, 0.0);
+        } else {
+            for n in &d.notes {
+                let mut head = format!("{} · Fahrer {}", dt(&n.created_at), n.author_personalnummer);
+                if n.is_amount_credit_note {
+                    head.push_str(" · [Gutschrift-Notiz]");
+                }
+                if n.image_attachment.is_some() {
+                    head.push_str(" · [Bild]");
+                }
+                p.text(&head, 8.0, true, 0.0);
+                if let Some(t) = &n.text {
+                    if !t.trim().is_empty() {
+                        p.text(t, 9.0, false, 4.0);
+                    }
+                }
+            }
+        }
+
+        // 7. Unterschriften
+        p.heading("Unterschriften");
+        match &d.completion {
+            Some(c) => {
+                // Es gibt nur EINEN Abschlusszeitpunkt (completed_at) — er gilt
+                // für beide Bestätigungen und wird hier neben den Häkchen gezeigt.
+                let bestätigt_am = dt(&c.completed_at);
+                let receipt = if c.receipt_confirmed {
+                    format!("Ja (am {bestätigt_am})")
+                } else {
+                    "Nein".to_string()
+                };
+                let notes = if c.notes_acknowledged {
+                    format!("Ja (am {bestätigt_am})")
+                } else {
+                    "Nein".to_string()
+                };
+                p.kv("Erhalt bestätigt", &receipt);
+                p.kv("Notizen quittiert", &notes);
+                if let Some(png) = &d.customer_signature_png {
+                    p.signature_box("Unterschrift Kunde", png);
+                }
+                if let Some(png) = &d.driver_signature_png {
+                    p.signature_box("Unterschrift Fahrer", png);
+                }
+            }
+            None => p.text("— Lieferung nicht abgeschlossen —", 9.0, false, 0.0),
+        }
+
+        // 8. Protokoll: Belade-/Scanverlauf
+        p.heading("Protokoll — Belade- und Scanverlauf");
+        if d.scan_audit.is_empty() {
+            p.text("— keine Einträge —", 9.0, false, 0.0);
+        } else {
+            p.row(
+                &[
+                    ("Zeit".to_string(), 30.0, true),
+                    ("Aktion".to_string(), 20.0, true),
+                    ("Artikel".to_string(), 58.0, true),
+                    ("Δ".to_string(), 10.0, true),
+                    ("Menge".to_string(), 16.0, true),
+                    ("Status".to_string(), 22.0, true),
+                    ("Fahrer".to_string(), 18.0, true),
+                ],
+                7.5,
+            );
+            for s in &d.scan_audit {
+                let art = s
+                    .article_name
+                    .clone()
+                    .unwrap_or_else(|| format!("Pos {}", s.belegzeilen_nr));
+                let mut action = scan_action_de(&s.action).to_string();
+                if s.manual {
+                    action.push('*');
+                }
+                p.row(
+                    &[
+                        (dt(&s.server_recorded_at), 30.0, false),
+                        (action, 20.0, false),
+                        (art, 58.0, false),
+                        (format!("{:+}", s.delta), 10.0, false),
+                        (s.resulting_quantity.to_string(), 16.0, false),
+                        (status_de(&s.resulting_status).to_string(), 22.0, false),
+                        (s.actor_personalnummer.to_string(), 18.0, false),
+                    ],
+                    7.5,
+                );
+                if let Some(r) = &s.reason {
+                    if !r.trim().is_empty() {
+                        p.text(&format!("   Grund: {r}"), 7.0, false, 0.0);
+                    }
+                }
+            }
+            p.text("* = manuell bestätigt", 7.0, false, 0.0);
+        }
+
+        // 9. Protokoll: Gutschriftverlauf
+        p.heading("Protokoll — Gutschriftverlauf");
+        if d.credit_audit.is_empty() {
+            p.text("— keine Einträge —", 9.0, false, 0.0);
+        } else {
+            p.row(
+                &[
+                    ("Zeit".to_string(), 34.0, true),
+                    ("Aktion".to_string(), 22.0, true),
+                    ("Betrag".to_string(), 26.0, true),
+                    ("Fahrer".to_string(), 20.0, true),
+                    ("Grund".to_string(), 70.0, true),
+                ],
+                7.5,
+            );
+            for c in &d.credit_audit {
+                p.row(
+                    &[
+                        (dt(&c.recorded_at), 34.0, false),
+                        (credit_action_de(&c.action).to_string(), 22.0, false),
+                        (cents(c.amount_cents), 26.0, false),
+                        (c.author_personalnummer.to_string(), 20.0, false),
+                        (c.reason.clone().unwrap_or_default(), 70.0, false),
+                    ],
+                    7.5,
+                );
+            }
+        }
+
+        // 10. Anhänge
+        p.heading("Anhänge");
+        if d.attachments.is_empty() {
+            p.text("— keine —", 9.0, false, 0.0);
+        } else {
+            for a in &d.attachments {
+                let meta = format!(
+                    "{} · {} · {} KB · hochgeladen {} von Fahrer {}",
+                    a.filename.clone().unwrap_or_else(|| "(ohne Name)".into()),
+                    a.mime_type,
+                    a.size_bytes / 1024,
+                    dt(&a.uploaded_at),
+                    a.uploaded_by
+                );
+                p.text(&meta, 8.0, true, 0.0);
+                match (&a.bytes, a.mime_type.starts_with("image/")) {
+                    (Some(bytes), true) => p.image(bytes, 90.0, 90.0),
+                    _ => p.text("   (Vorschau nicht verfügbar)", 8.0, false, 0.0),
+                }
+            }
+        }
+
+        // 11. Footer
+        p.gap(4.0);
+        p.text(
+            &format!("Automatisch erzeugt am {} — Holzleitner Auslieferung", dt(&d.generated_at)),
+            7.0,
+            false,
+            0.0,
+        );
+
+        p.finish()
+    }
+}