Webklar-Kundenbereich/docs/superpowers/plans/2026-10-06-auftraege-05-ab-pdf.md

AB-PDF – Umsetzungsplan (Strang L4)

For agentic workers: REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (- [ ]) syntax for tracking.

Goal: Das PDF der Auftragsbestätigung (A4, Figtree, WEBklar-Logo, Briefkopf mit Steuernummer, Positionstabelle mit Seitenumbruch und Kopf auf jeder Folgeseite, Zahlungsplan, bei Privatpersonen Widerrufsbelehrung und Muster-Widerrufsformular, Fuß mit Bankverbindung und „Seite X von Y“, bei Vorschau „Entwurf“) als reine Datenfunktion auftragPdfDaten und Zeichnung erzeugeAuftragPdf mit pdfkit – ohne Chrome und ohne neue Abhängigkeiten.

Architecture: Alles Produktive steht in einer Datei, server/services/auftraege/pdf.js (so legt es die Dateitabelle der Übersicht fest), in fünf Abschnitten mit Kommentarüberschrift: 1 Schriften (Figtree-Dateien und Logo einmal je Prozess laden, Zeichenabdeckung prüfen, Zeichen ohne Glyph ersetzen), 2 Daten (auftragPdfDaten: alle Texte und Zahlen fertig formatiert), 3 Layout (rein, ohne pdfkit: Maße, Bausteine mit Höhen, paginiere), 4 Zeichnen (pdfkit), 5 Ablauf (erzeugeAuftragPdf). Gemessen und gezeichnet wird mit denselben Stilen; die Seitenzahl steht vor dem Zeichnen fest, deshalb braucht es weder bufferPages noch einen zweiten Durchlauf.

Tech Stack: Node 20.19 (Container) und 24 (Host), ES-Module, pdfkit 0.20.x (Node ≥ 20, von L0 installiert), fontkit 2.0.4 (direkte Abhängigkeit, von L0 in package.json eingetragen; hasGlyphForCodePoint), Figtree 2.002 in den statischen Schnitten Regular und SemiBold (SIL OFL 1.1) aus dem npm-Paket @expo-google-fonts/figtree@0.4.1, Tests mit node:test.

Spec: docs/superpowers/specs/2026-10-06-auftraege-und-rechnungen-design.md (Abschnitt 2 „Inhalt des PDFs“ und „Erzeugung und Ablage“)

Übersicht/Verträge: docs/superpowers/plans/2026-10-06-auftraege-00-uebersicht.md (V3 Datenformen, V4 „L4 – AB-PDF“, V7 Texte, Review Focus 5 und der Abschnitt „Nachträge nach der Planrunde“; im Zweifel gilt die Übersicht). Die „Vertragsfragen“ am Ende tragen ihren Entscheidungsstand.

Worktree: /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4, Branch auftraege/l4-ab-pdf (aus feature/auftraege nach L0).

Referenzstand (nur zum Nachschlagen): /tmp/claude-0/-root/dc97e1da-8b3d-40c0-9943-f8c37f910877/scratchpad/pdfprobe/ enthält eine lauffähige Vorstufe von pdf.js und aller Tests dieses Plans (mit Ersatzdateien für die L0-Module unter server/services/auftraege/) sowie gerenderte Beispielseiten in out/. Maßgeblich sind die Tests in diesem Plan, nicht der Referenzstand; nichts daraus gehört ins Repo.

Global Constraints

Alle Punkte der Übersicht gelten. Zusätzlich für diesen Strang:

• Sonderzeichen im Quelltext nur als \u{…} (mit Klammern) oder String.fromCodePoint(…) schreiben, nie als vierstelliges \uXXXX: die Werkzeugschicht macht daraus beim Schreiben das Zeichen selbst (unsichtbare NBSP, U+2028 in Tests und Regexen). Sichtbare Zeichen (ä, ß, €, „ “, –) dürfen wörtlich im Quelltext stehen. Regexe mit \u{…} brauchen das Flag u.
• pdfkit: import PDFDocument from 'pdfkit' nur in pdf.js. Seitenränder von pdfkit auf 0 (margins: { top: 0, bottom: 0, left: 0, right: 0 }); die Geometrie steht allein im Abschnitt „Layout“ von pdf.js. Jeder Text wird mit width gemessen und gezeichnet (ohne width nimmt pdfkit die Seitenbreite; mit Rand 0 fügt pdfkit auch nie selbst eine Seite ein).
• Schriften und Logo: nur Figtree Regular und SemiBold aus server/assets/fonts/ (mit Figtree-OFL.txt daneben) und public/webklar-logo.png; alles wird über ladeSchriften() einmal je Prozess gelesen. Kein Helvetica im PDF.
• Alles Gedruckte kommt aus AuftragPdfDaten (auch Beschriftungen und „Seite x von y“). Vor Messen und Zeichnen läuft bereinigeTexte über die Daten. Die Uhr kommt als Parameter jetzt (Vorgabe new Date()), nie als Date.now() im Funktionskörper.
• Wortlaute nur aus texte.js und auftragSicht.js (L7 ändert sie später); Tests vergleichen mit den Rückgabewerten dieser Funktionen, nie mit eigenen Wortlauten. Ausnahmen sind die in V7 festgelegten Werte (ABSENDER, kleinunternehmer und der Satz „Ohne Ihr ausdrückliches Verlangen beginnen wir erst nach Ablauf der Widerrufsfrist.“, den AB_TEXTE.termine bei Privatpersonen liefert).
• Keine neuen Abhängigkeiten (kein devDependency, kein PDF-Werkzeug in Tests; der Textleser der Tests nutzt nur node:zlib). package.json bleibt unberührt.
• Dateien: nur die der Tabelle unten; je Task ein Commit mit einzeln genannten Dateien; kein Push.

Review Focus

1. Umlaute, ß, €, Minuszeichen und lange Texte (Review Focus 5 der Übersicht: ä ö ü ß €, „−“ U+2212, 200 Zeichen ohne Leerzeichen, 20 Positionen über eine Seite): lesbar, kein Glyphenausfall, Seitenumbruch mit Tabellenkopf – Tests in Task 3, Task 7 und Task 9 (Umlaute …, 20 Positionen …).
2. Zeichen ohne Glyph in Kundendaten (kyrillische oder japanische Namen, Emoji, schmale Leerzeichen und Zero-Width-Zeichen aus Copy-and-paste): nie ein leeres Kästchen, sondern die Ersatzregel (Leerzeichen, ?, entfernt) – Tests in Task 3 und Task 9 (Zeichen ohne Glyph …).
3. Texte aus texte.js mit Zeichen jenseits von Figtree oder sehr langer Belehrung (L7 formuliert später): ein Wächter-Test schlägt an, statt dass der freigegebene Wortlaut still verändert wird; eine lange Belehrung läuft über mehrere Seiten, das Formular bleibt zusammen – Tests in Task 5 (Wächter …) und Task 7 (lange Widerrufsbelehrung …).
4. Unvollständiger Entwurf und leere Angaben (Vorschau mit fehlendem Datum oder fehlenden Positionen, keine Steuernummer, keine Kundennummer, keine Termine, keine Bankverbindung, Land Deutschland): kein „undefined“ und kein Absturz im Zeichnen; fehlende Pflichtangaben ergeben 409 mit Klartext, leere optionale Angaben lassen ihre Zeile weg; bei Privatpersonen steht der Abschnitt „Termine“ auch ohne Daten da (Satz zum Beginn nach Ablauf der Widerrufsfrist), bei Unternehmen ohne Daten nicht – Tests in Task 4 (Fehlende Pflichtangaben …, Anschrift …), Task 5 (Fuß …, Termine: Privatpersonen …) und Task 9 (Privatperson: …).
5. Seitenumbruch an der Kante: Überschrift nie allein am Seitenende, Summe nie ohne die letzte Position, Tabellenkopf auf jeder Folgeseite, zu hohe Bausteine und Ketten führen nicht zur Endlosschleife – Tests in Task 6.

Dateien dieses Strangs

Datei	Zweck
server/services/auftraege/pdf.js	alles Produktive; Exporte ladeSchriften, hatGlyph, bereinigeText, bereinigeTexte, PDF_BESCHRIFTUNG, auftragPdfDaten, SEITE, INHALT_BREITE, SPALTEN, BEREICHE, baueAtome, paginiere, erzeugeAuftragPdf
server/assets/fonts/	Figtree-Regular.ttf, Figtree-SemiBold.ttf, Figtree-OFL.txt, QUELLE.txt
test/auftraegePdfSchrift.test.js, test/auftraegePdfDaten.test.js, test/auftraegePdfLayout.test.js, test/auftraegePdfLeser.test.js, test/auftraegePdf.test.js, test/auftraegePdfErsetzt.test.js	Tests
test/auftraegePdfHilfe.js	Testhilfe (Beispiel-Auftrag, Textleser); endet nicht auf .test.js, npm test startet sie nicht; Testhilfen gehören laut Übersicht (Nachträge) dem anlegenden Strang, wie auftraegeRechnungenHilfe.js und auftraegeBestaetigungHilfe.js der Nachbarstränge

Damit bleibt dieser Strang bei den Dateien der Übersicht (pdf.js, server/assets/fonts/*, eigene Testdateien); QUELLE.txt liegt im Schriftordner, zur Testhilfe siehe Vertragsfrage 10 (entschieden).

---

Task 1: Worktree einrichten und Voraussetzungen prüfen

Files:

• Create: Worktree /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 (Branch auftraege/l4-ab-pdf)

Interfaces:

• Consumes (L0, müssen vorhanden sein): konstanten.js (AUFTRAG_ARTEN, AUFTRAG_WEGE, ZAHLUNGSPLAN_ARTEN, AGB_FASSUNG), fehler.js (AuftragError), texte.js (ABSENDER, AB_TEXTE, WIDERRUFSBELEHRUNG_PROJEKT, WIDERRUFSFORMULAR), auftragSicht.js (zahlungsplanText(auftrag), aufwandText(auftrag)), auftragStore.js (getAuftrag(id)), finance/format.js (euroDe), finance/dates.js (berlinDate, formatDe); pdfkit und fontkit in node_modules und in dependencies.

• Produces: den Arbeitsplatz für alle folgenden Tasks.

• Step 1: Worktree und Symlink anlegen

git -C /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege worktree add ../dev-auftraege-l4 -b auftraege/l4-ab-pdf feature/auftraege
cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && ln -s ../dev-auftraege/node_modules node_modules
git status --short

Erwartet: keine Ausgabe. L0 hat node_modules (ohne Schrägstrich) in .gitignore eingetragen (Übersicht, Nachträge), damit ist auch der Symlink ignoriert. Erscheint doch ?? node_modules, fehlt der Eintrag: dem Orchestrator melden und weiterarbeiten (Dateien ohnehin einzeln mit git add, nie git add -A).

• Step 2: L0-Module und ihre Exporte prüfen

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && node --input-type=module -e "
const soll = {
  './server/services/auftraege/konstanten.js': ['AUFTRAG_ARTEN', 'AUFTRAG_WEGE', 'ZAHLUNGSPLAN_ARTEN', 'AGB_FASSUNG'],
  './server/services/auftraege/fehler.js': ['AuftragError'],
  './server/services/auftraege/texte.js': ['ABSENDER', 'AB_TEXTE', 'WIDERRUFSBELEHRUNG_PROJEKT', 'WIDERRUFSFORMULAR'],
  './server/services/auftraege/auftragSicht.js': ['zahlungsplanText', 'aufwandText'],
  './server/services/auftraege/auftragStore.js': ['getAuftrag'],
}
for (const [datei, namen] of Object.entries(soll)) {
  const modul = await import(datei)
  const fehlt = namen.filter((n) => !(n in modul))
  console.log(datei, fehlt.length ? 'FEHLT: ' + fehlt.join(', ') : 'ok')
}
"

Erwartet: fünfmal ok. Fehlt etwas, den Strang anhalten und dem Orchestrator melden (kein Nachbau in L4). Außerdem dürfen server/services/auftraege/pdf.js und server/assets/fonts/ noch nicht existieren (ls meldet beides als fehlend); gibt es sie schon, heißt „Create“ in den Tasks 2 und 4 „Modify“ – dann dem Orchestrator melden.

• Step 3: pdfkit und fontkit prüfen

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && node --input-type=module -e "
import PDFDocument from 'pdfkit'
import * as fontkit from 'fontkit'
import { readFileSync } from 'node:fs'
const paket = JSON.parse(readFileSync('package.json', 'utf8'))
console.log(typeof PDFDocument, typeof (fontkit.default ?? fontkit).create, JSON.parse(readFileSync('node_modules/pdfkit/package.json', 'utf8')).version, paket.dependencies.pdfkit, paket.dependencies.fontkit)
"

Erwartet: function function 0.20.… und danach die Einträge von pdfkit und fontkit aus dependencies (beide da: L0 trägt fontkit seit der Planrunde als direkte Abhängigkeit ein, Vertragsfrage 8). Fehlt der Eintrag oder schlägt der Import fehl, dem Orchestrator melden.

• Step 4: Schema-Nachbau für Task 10 prüfen

Run: cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && command grep -a -n "auftraege" test/support/schema.js Erwartet: mindestens ein Treffer (L0 hat schemaKeys('auftraege') eingerichtet). Ohne Treffer nur den Test in Task 10 (auftraegePdfErsetzt.test.js) zurückstellen und melden.

Kein Commit in diesem Task.

---

Task 2: Schriften und Logo laden, Glyphen prüfen

Files:

• Create: server/assets/fonts/Figtree-Regular.ttf, server/assets/fonts/Figtree-SemiBold.ttf, server/assets/fonts/Figtree-OFL.txt, server/assets/fonts/QUELLE.txt
• Create: server/services/auftraege/pdf.js (zunächst nur Abschnitt 1 „Schriften“)
• Test: test/auftraegePdfSchrift.test.js

Interfaces:

• Consumes: nichts aus anderen Tasks.
• Produces (pdf.js): ladeSchriften() → { regular: Buffer, semibold: Buffer, logo: Buffer, regularFont, semiboldFont } (eingefrorenes Objekt, bei jedem Aufruf dasselbe; …Font sind fontkit-Schriften); hatGlyph(codePoint: number) → boolean (Glyph in Regular und SemiBold).

Quelle der Schriften: fontkit liest zwar WOFF2 (mit den Dateien aus public/fonts geprüft), aber diese Dateien sind variabel (Standardgewicht „Light“) und in latin und latin-ext zerlegt; die woff2-Dateien von @fontsource/figtree sind es ebenfalls (zwei Dateien je Gewicht, ein Zeichen aus dem zweiten Teil bräuchte einen Schriftwechsel mitten im Text). @expo-google-fonts/figtree@0.4.1 liefert dagegen je Gewicht eine vollständige statische TTF (Latin und Latin Extended in einer Datei, 392 Codepunkte, je rund 40 KB).

• Step 1: Failing Test schreiben

test/auftraegePdfSchrift.test.js (Task 3 hängt weitere Tests an; die Importzeile nennt die Namen von Task 3 schon, sie sind bis dahin undefined):

import { test } from 'node:test'
import assert from 'node:assert/strict'
import { createHash } from 'node:crypto'
import { readFileSync, readdirSync } from 'node:fs'
import { useTestEnv } from './support/testEnv.js'

const FONTS = new URL('../server/assets/fonts/', import.meta.url)
const sha256 = (datei) => createHash('sha256').update(readFileSync(new URL(datei, FONTS))).digest('hex')
const cp = (...codes) => String.fromCodePoint(...codes)
const NBSP = cp(0xa0)

test('Schriftdateien: Figtree Regular und SemiBold samt OFL-Lizenz und Quellenangabe liegen unverändert vor', () => {
  assert.deepEqual(readdirSync(FONTS).sort(), ['Figtree-OFL.txt', 'Figtree-Regular.ttf', 'Figtree-SemiBold.ttf', 'QUELLE.txt'])
  assert.equal(sha256('Figtree-Regular.ttf'), '4e2e9876c4a908c2cbe410ceb648e4724464a84492bd49cb2d6e7b0d3f769a66')
  assert.equal(sha256('Figtree-SemiBold.ttf'), '1b76aae525b51758fc0c9c5096f33d90831657d3ad2fe3c34fb7e666d76f8960')
  assert.equal(sha256('Figtree-OFL.txt'), '140d37233e7f3ce7313798befa9600893bcceaf41a55fa0fa5ad52f7f657a268')
  assert.match(readFileSync(new URL('Figtree-OFL.txt', FONTS), 'utf8'), /^Copyright 2022 The Figtree Project Authors/)
  assert.match(readFileSync(new URL('QUELLE.txt', FONTS), 'utf8'), /@expo-google-fonts\/figtree@0\.4\.1/)
})

useTestEnv({ appwriteUrl: 'http://127.0.0.1:1', stripeUrl: 'http://127.0.0.1:1' })
const { ladeSchriften, hatGlyph, bereinigeText, bereinigeTexte } = await import('../server/services/auftraege/pdf.js')

test('ladeSchriften: Dateien werden einmal je Prozess gelesen, jeder Aufruf liefert dasselbe Objekt', () => {
  const schriften = ladeSchriften()
  assert.equal(ladeSchriften(), schriften)
  assert.equal(schriften.regularFont.postscriptName, 'Figtree-Regular')
  assert.equal(schriften.semiboldFont.postscriptName, 'Figtree-SemiBold')
  assert.equal(schriften.regular.length, 40140)
  assert.equal(schriften.logo.subarray(1, 4).toString('latin1'), 'PNG')
})

test('hatGlyph: deutsche Buchstaben, €, Minuszeichen, geschütztes Leerzeichen und typografische Zeichen sind in beiden Schnitten da', () => {
  const noetig = [
    ...'äöüÄÖÜ߀§%/&()@:;,.!?+*#"\'0123456789 ',
    NBSP, cp(0x2212), cp(0x2013), cp(0x2014), cp(0x201e), cp(0x201c), cp(0x201d), cp(0x2018), cp(0x2019), cp(0x2026), cp(0x2022), cp(0xb7), cp(0xd7),
    'ł', 'ğ', 'Ş', 'ő', 'ř', 'ı',
  ]
  for (const zeichen of noetig) assert.ok(hatGlyph(zeichen.codePointAt(0)), `Glyph fehlt: U+${zeichen.codePointAt(0).toString(16)}`)
  for (const code of [0x202f, 0x2009, 0x200b, 0x416, 0x1f600, 0x3042]) assert.equal(hatGlyph(code), false, `U+${code.toString(16)} sollte fehlen`)
})

• Step 2: Lauf, erwartet FAIL

Run: cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && timeout 900 nice -n 10 node --max-old-space-size=1024 --test test/auftraegePdfSchrift.test.js Erwartet: FAIL („Cannot find module …/pdf.js“; das Schriftverzeichnis fehlt).

• Step 3: Schriften beschaffen und Abschnitt „Schriften“ in pdf.js schreiben

Dateien holen (npm pack lädt nur das Paket in den Scratchpad, kein npm install):

S=/tmp/claude-0/-root/dc97e1da-8b3d-40c0-9943-f8c37f910877/scratchpad/auftraege-fonts
mkdir -p $S && cd $S && timeout 120 npm pack @expo-google-fonts/figtree@0.4.1
tar -xzf expo-google-fonts-figtree-0.4.1.tgz package/400Regular/Figtree_400Regular.ttf package/600SemiBold/Figtree_600SemiBold.ttf package/LICENSE_FONT
W=/home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4/server/assets/fonts
mkdir -p $W
cp package/400Regular/Figtree_400Regular.ttf $W/Figtree-Regular.ttf
cp package/600SemiBold/Figtree_600SemiBold.ttf $W/Figtree-SemiBold.ttf
cp package/LICENSE_FONT $W/Figtree-OFL.txt
sha256sum $W/*

Erwartet: 4e2e9876…9a66 für Regular, 1b76aae5…8960 für SemiBold, 140d3723…a268 für Figtree-OFL.txt (volle Werte stehen im Test). Dazu server/assets/fonts/QUELLE.txt mit genau diesem Inhalt:

Figtree, statische TrueType-Schnitte Regular (400) und SemiBold (600) für das PDF der Auftragsbestätigung.
Lizenz: SIL Open Font License 1.1, Text in Figtree-OFL.txt.
Quelle: npm-Paket @expo-google-fonts/figtree@0.4.1 (400Regular/Figtree_400Regular.ttf, 600SemiBold/Figtree_600SemiBold.ttf, LICENSE_FONT als Figtree-OFL.txt), Stand 2026-10-06.
SHA-256 Figtree-Regular.ttf: 4e2e9876c4a908c2cbe410ceb648e4724464a84492bd49cb2d6e7b0d3f769a66
SHA-256 Figtree-SemiBold.ttf: 1b76aae525b51758fc0c9c5096f33d90831657d3ad2fe3c34fb7e666d76f8960

server/services/auftraege/pdf.js (neu; Kopfkommentar „PDF der Auftragsbestätigung …“ mit den fünf Abschnitten, dann // ===== 1. Schriften, Logo, Zeichenabdeckung =====) mit den Exporten oben:

• import * as fontkitModul from 'fontkit' und const fontkit = fontkitModul.default ?? fontkitModul (die ESM-Fassung von fontkit 2.0.4 hat nur benannte Exporte, create inklusive).

• Pfade relativ zur Datei: new URL('../../assets/fonts/', import.meta.url) und new URL('../../../public/webklar-logo.png', import.meta.url).

• ladeSchriften() liest beim ersten Aufruf beide TTFs und das Logo als Buffer, erzeugt mit fontkit.create(buffer) die beiden Schriften und merkt sich das eingefrorene Ergebnis in einer Modulvariablen.

• hatGlyph(codePoint) fragt hasGlyphForCodePoint an beiden fontkit-Schriften ab.

• Step 4: Lauf, erwartet PASS

Run: cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && timeout 900 nice -n 10 node --max-old-space-size=1024 --test test/auftraegePdfSchrift.test.js Erwartet: die drei Tests dieses Tasks bestehen; die Tests von Task 3 gibt es noch nicht.

• Step 5: Commit

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4
git add server/assets/fonts/Figtree-Regular.ttf server/assets/fonts/Figtree-SemiBold.ttf server/assets/fonts/Figtree-OFL.txt server/assets/fonts/QUELLE.txt server/services/auftraege/pdf.js test/auftraegePdfSchrift.test.js
git commit -m "AB-PDF: Figtree Regular und SemiBold (OFL) mit Schriftlader und Glyphenprüfung

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

---

Task 3: Zeichen ohne Glyph ersetzen

Files:

• Modify: server/services/auftraege/pdf.js (Abschnitt 1)
• Test: test/auftraegePdfSchrift.test.js

Interfaces:

• Consumes: hatGlyph(codePoint) aus Task 2.
• Produces: bereinigeText(text: unknown, hatGlyphFn = hatGlyph) → string; bereinigeTexte<T>(wert: T, hatGlyphFn = hatGlyph) → T' (jede Zeichenkette in beliebig verschachtelten Objekten und Listen durch bereinigeText; Zahlen, null, Wahrheitswerte bleiben; liefert neue Objekte, ändert die Eingabe nicht).

Ersatzregel (Review Focus 1 und 2), in dieser Reihenfolge:

1. String(text ?? ''), normalize('NFC'); \r\n, \r, U+2028 und U+2029 werden \n; Tab wird Leerzeichen; entfernt werden Steuerzeichen außer \n (U+0000–U+0008, U+000B–U+001F, U+007F–U+009F), U+00AD, U+200B–U+200D, U+2060, U+FE00–U+FE0F und U+FEFF.
2. Je Codepunkt: \n oder hatGlyphFn(codePoint) → unverändert.
3. Sonst steht der Codepunkt in ERSATZ → dessen Ersatz.
4. Sonst Leerzeichen-Art (\p{Zs}) → ein Leerzeichen.
5. Sonst kombinierendes Zeichen (\p{M}) → entfällt.
6. Sonst erster Codepunkt von zeichen.normalize('NFD'), falls er sich vom Zeichen unterscheidet und ein Glyph hat (ğ → g, Å → A) → dieser Buchstabe.
7. Sonst ?.

const ERSATZ = new Map([
  [0x2010, '-'], [0x2011, '-'], [0x2012, '-'], [0x2013, '-'], [0x2014, '-'], [0x2015, '-'], [0x2212, '-'],
  [0x2018, "'"], [0x2019, "'"], [0x201a, "'"], [0x2032, "'"],
  [0x201c, '"'], [0x201d, '"'], [0x201e, '"'], [0x201f, '"'], [0x2033, '"'],
  [0x2026, '...'], [0x20ac, 'EUR'], [0x2022, '-'], [0x00b7, '-'], [0x00d7, 'x'], [0x2192, '->'],
])
// Steuerzeichen (außer \n), weiche Trennung, Zero-Width-Zeichen, Variantenselektoren, BOM
const ENTFERNEN = /[\u{0}-\u{8}\u{B}-\u{1F}\u{7F}-\u{9F}\u{AD}\u{200B}-\u{200D}\u{2060}\u{FE00}-\u{FE0F}\u{FEFF}]/gu

• Step 1: Failing Tests anhängen

An test/auftraegePdfSchrift.test.js anhängen:

test('bereinigeText: vorhandene Zeichen bleiben unverändert, getrennte Akzente werden zusammengesetzt', () => {
  const text = `Müller & Söhne – „Größe“ 1.234,56${NBSP}€ ${cp(0x2212)} 20,00${NBSP}€ ÄÖÜ äöü ß … Łukasz Yıldız Çelik`
  assert.equal(bereinigeText(text), text)
  assert.equal(bereinigeText('a' + cp(0x301)), 'á'.normalize('NFC'))
  assert.equal(bereinigeText(null), '')
  assert.equal(bereinigeText(undefined), '')
  assert.equal(bereinigeText(42), '42')
})

test('bereinigeText: Steuerzeichen, Zero-Width, weiche Trennung und BOM entfallen; Zeilenenden werden Zeilenumbrüche, Tab wird Leerzeichen', () => {
  const roh = `a${cp(0x200b)}b${cp(0xad)}c${cp(0xfeff)}d${cp(0)}e\tf\r\ng\rh${cp(0x2028)}i${cp(0x200d, 0xfe0f)}j`
  assert.equal(bereinigeText(roh), 'abcde f\ng\nh\nij')
})

test('bereinigeText mit Figtree: schmale Leerzeichen werden Leerzeichen, kyrillische und japanische Zeichen sowie Emoji je ein Fragezeichen', () => {
  assert.equal(bereinigeText(`a${cp(0x202f)}b${cp(0x2009)}c`), 'a b c')
  assert.equal(bereinigeText(`${cp(0x416)}${cp(0x3042)}${cp(0x1f600)}`), '???')
})

test('bereinigeText: Ersatzregeln bei fehlendem Glyph (Schrift ohne Zeichen über ASCII)', () => {
  const nurAscii = (code) => code < 0x80
  const fall = (eingabe) => bereinigeText(eingabe, nurAscii)
  assert.equal(fall('9,00' + NBSP + '€'), '9,00 EUR')
  assert.equal(fall(`${cp(0x201e)}x${cp(0x201c)} ${cp(0x201a)}y${cp(0x2019)}`), `"x" 'y'`)
  assert.equal(fall(`1 ${cp(0x2013)} 2 ${cp(0x2212)} 3 ${cp(0x2014)} 4`), '1 - 2 - 3 - 4')
  assert.equal(fall(`wait${cp(0x2026)} 3${cp(0xd7)}4 a${cp(0x2192)}b`), 'wait... 3x4 a->b')
  assert.equal(fall('Müller Çelik Ångström'), 'Muller Celik Angstrom')
  assert.equal(fall('Łukasz Ğ'), '?ukasz G')
  assert.equal(fall('e' + cp(0x301) + cp(0x301)), 'e')
  assert.equal(fall(cp(0x301)), '')
})

test('bereinigeTexte: bearbeitet jede Zeichenkette in verschachtelten Objekten und Listen, andere Werte bleiben', () => {
  const roh = { a: ['x' + cp(0x200b) + 'y', { b: 'ż' + cp(0x1f600) }], n: 5, f: null, t: true }
  assert.deepEqual(bereinigeTexte(roh), { a: ['xy', { b: 'ż?' }], n: 5, f: null, t: true })
})

• Step 2: Lauf, erwartet FAIL

Run: cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && timeout 900 nice -n 10 node --max-old-space-size=1024 --test test/auftraegePdfSchrift.test.js Erwartet: die fünf neuen Tests scheitern („bereinigeText is not a function“), die drei alten bestehen.

• Step 3: bereinigeText und bereinigeTexte in Abschnitt 1 von pdf.js ergänzen

Beides mit den Signaturen und der Regel oben; die Konstanten ERSATZ (Map Codepunkt → Ersatz) und ENTFERNEN (Regex mit Flag u) wie im Block oben.

• Step 4: Lauf, erwartet PASS

Run: derselbe wie in Step 2. Erwartet: alle acht Tests bestehen.

• Step 5: Commit

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4
git add server/services/auftraege/pdf.js test/auftraegePdfSchrift.test.js
git commit -m "AB-PDF: Zeichen ohne Glyph werden ersetzt statt als Kästchen gedruckt

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

---

Task 4: auftragPdfDaten – Kopf, Anschrift, Leistung, Prüfung der Pflichtangaben

Files:

• Modify: server/services/auftraege/pdf.js (Importe oben ergänzen, Abschnitt 2 „Daten“ anhängen: zunächst PDF_BESCHRIFTUNG und auftragPdfDaten)
• Create: test/auftraegePdfHilfe.js (Beispiel-Auftrag und alleTexte; Task 8 ergänzt den Textleser)
• Test: test/auftraegePdfDaten.test.js

Interfaces:

• Consumes: AuftragError(status, message) (fehler.js); AUFTRAG_ARTEN, AUFTRAG_WEGE, ZAHLUNGSPLAN_ARTEN, AGB_FASSUNG (konstanten.js); ABSENDER, AB_TEXTE (texte.js, V7); aufwandText(auftrag) → string|null, zahlungsplanText(auftrag) → string (auftragSicht.js, V3); euroDe(cents); berlinDate(date), formatDe(ymd).
• Produces (pdf.js): PDF_BESCHRIFTUNG (Beschriftungen, siehe Block); auftragPdfDaten(auftrag: Auftrag, { settings = {}, vorschau = false, jetzt = new Date(), ersetzt = null } = {}) → AuftragPdfDaten. settings = { steuernummer, bankDetailsText } (V4), jetzt und ersetzt = { nummer, datum /* 'YYYY-MM-DD' */ } stehen seit der Planrunde in V4 (Vertragsfragen 1 und 2: entschieden). Die Funktion ist rein und wirft nur AuftragError.

PDF_BESCHRIFTUNG (eingefroren, in pdf.js exportiert):

export const PDF_BESCHRIFTUNG = Object.freeze({
  nummer: 'Nummer', datum: 'Datum', kundennummer: 'Kundennummer', projekt: 'Projekt',
  leistung: 'Leistungsumfang', zahlung: 'Zahlung', termine: 'Termine', mitwirkung: 'Mitwirkung und Abnahme',
  spalten: Object.freeze(['Pos.', 'Beschreibung', 'Menge', 'Einzelpreis', 'Summe']), gesamt: 'Gesamtpreis',
  steuernummer: 'Steuernummer', telefon: 'Telefon', bank: 'Bankverbindung', kontakt: 'Kontakt', seite: 'Seite', von: 'von',
  entwurf: 'ENTWURF', entwurfHinweis: 'Entwurf – Vorschau, noch keine gültige Auftragsbestätigung',
})

Form von AuftragPdfDaten (alles Zeichenketten, fertig formatiert). Task 4 liefert die Felder bis kleinunternehmer, Task 5 den Rest:

{
  vorschau: boolean,
  beschriftung: PDF_BESCHRIFTUNG,
  titel: AB_TEXTE.titel,
  nummer: 'AB-2026-0007',                  // auftrag.nummer, sonst 'Entwurf'
  datum: '06.10.2026',                     // Berliner Tag von gesendetAm, sonst von jetzt
  kundennummer: 'K-1042',                  // kunde.kundennummer oder ''
  projekt: 'Neue Website …',               // auftrag.titel, getrimmt
  absender: { zeilen: string[], rueckzeile: string },
  empfaenger: string[],
  einleitung: string,
  leistung: {
    art: 'festpreis' | 'aufwand', ueberschrift: 'Leistungsumfang',
    positionen: [{ nr: '1', beschreibung, menge: '2', einzelpreis: '100,00 €', summe: '200,00 €' }],   // Aufwand: []
    gesamt: { label: 'Gesamtpreis', betrag: '800,00 €' } | null,                                      // Aufwand: null
    aufwandText: string | null,                                                                        // nur Aufwand
  },
  kleinunternehmer: AB_TEXTE.kleinunternehmer,
  // Task 5:
  abschnitte: [{ id: 'zahlung' | 'termine' | 'mitwirkung', ueberschrift, text }],
  agb: string, ersetzt: string | null, gruss: string,
  widerruf: { belehrung: WIDERRUFSBELEHRUNG_PROJEKT, formular: WIDERRUFSFORMULAR } | null,
  fuss: { bank: string[], kontakt: string[] },
}

Regeln für die Felder von Task 4:

• nummer: auftrag.nummer || 'Entwurf'. datum: formatDe(berlinDate(new Date(auftrag.gesendetAm || jetzt))). projekt: auftrag.titel.trim().
• absender.zeilen: ABSENDER.name, strasse, plzOrt, Telefon <telefon>, email, web, und Steuernummer <settings.steuernummer> nur, wenn die (getrimmte) Steuernummer nicht leer ist. rueckzeile: <name> · <strasse> · <plzOrt> (mit Mittelpunkt U+00B7).
• empfaenger: kunde.firma, kunde.name, kunde.strasse, <plz> <ort> (leere Teile entfallen), kunde.land nur, wenn es nicht Deutschland, DE oder Germany ist (ohne Beachtung der Groß-/Kleinschreibung); jede Zeile getrimmt, leere und doppelte Zeilen entfallen (Firma gleich Name erscheint einmal).
• einleitung: AB_TEXTE.einleitung({ datum: formatDe(auftrag.auftragVom), weg: AUFTRAG_WEGE[auftrag.auftragWeg] }) – weg ist der Anzeigetext („telefonisch“), nicht der Schlüssel (Vertragsfrage 4).
• leistung Festpreis: positionen aus auftrag.positionen (nr ab '1', beschreibung getrimmt, menge als Text, einzelpreis und summe = menge × einzelpreisCents über euroDe), gesamt.betrag = euroDe(auftrag.summeCents). Aufwand: positionen: [], gesamt: null, aufwandText: aufwandText(auftrag).
• Prüfung vor allem anderen (AuftragError(409, …)), in dieser Reihenfolge, je Bedingung genau diese Meldung:

Bedingung	Meldung
auftrag.kunde fehlt oder ist kein Objekt	Entwurf unvollständig: Kundendaten fehlen.
ohne vorschau: nummer leer	Entwurf unvollständig: Nummer fehlt.
titel nach trim() leer	Entwurf unvollständig: Titel fehlt.
auftragVom nicht JJJJ-MM-TT	Entwurf unvollständig: Datum der Absprache fehlt.
auftragWeg nicht in AUFTRAG_WEGE	Entwurf unvollständig: Weg der Absprache fehlt.
art nicht in AUFTRAG_ARTEN	Entwurf unvollständig: Art des Auftrags fehlt.
zahlungsplan.art nicht in ZAHLUNGSPLAN_ARTEN	Entwurf unvollständig: Zahlungsplan fehlt.
Festpreis ohne Positionen	Entwurf unvollständig: Positionen fehlen.
Festpreis: Σ menge × einzelpreisCents ≠ summeCents	Die Summe der Positionen stimmt nicht mit der Auftragssumme überein.
Aufwand: stundensatzCents keine positive sichere Ganzzahl	Entwurf unvollständig: Stundensatz fehlt.

• Step 1: Testhilfe und Failing Tests schreiben

test/auftraegePdfHilfe.js (neu; Task 8 ergänzt am Anfang import { inflateSync } from 'node:zlib' und hängt seitenZahl und leseSeiten an):

/** Beispiel-Auftrag (V3-Form) für die PDF-Tests; `extra` überschreibt einzelne Felder. */
export function beispielAuftrag(extra = {}) {
  return {
    id: 'ab1', nummer: 'AB-2026-0007', jahr: 2026, laufnummer: 7, status: 'versendet', kundenId: 'k1',
    kunde: {
      name: 'Anna Müller', firma: 'Müller Bäckerei GmbH', strasse: 'Hauptstraße 12', plz: '67722', ort: 'Winnweiler',
      land: 'Deutschland', email: 'anna@example.test', kundenart: 'unternehmen', kundennummer: 'K-1042',
    },
    projektId: 'p1', titel: 'Neue Website Müller Bäckerei', zeitquelle: ['t1'], art: 'festpreis',
    positionen: [
      { beschreibung: 'Gestaltung und Umsetzung der Website (5 Seiten)', menge: 1, einzelpreisCents: 60000 },
      { beschreibung: 'Kontaktformular mit E-Mail-Versand', menge: 2, einzelpreisCents: 10000 },
    ],
    stundensatzCents: null, schaetzungMinuten: null, summeCents: 80000,
    zahlungsplan: { art: 'anzahlung', prozent: 50, text: '' }, zahlungszielTage: 14,
    auftragVom: '2026-10-05', auftragWeg: 'telefon', startAm: '2026-10-12', fertigBis: '2026-11-15',
    ersetztId: '', ersetztDurchId: '', texteFassung: '2026-10-06', agbFassung: '2026-09-30', pdfDatei: '', pdfSha256: '',
    gesendetAm: '2026-10-06T08:30:00.000Z', gesendetAn: 'anna@example.test', mailStatus: '', mailFehler: '',
    tokenHash: '', tokenGueltigBis: null, bestaetigtAm: null, bestaetigtUeber: '', bestaetigtPdfSha256: '',
    fruehbeginn: false, fruehbeginnFassung: '', storniertAm: null, widerrufenAm: null,
    erstelltVon: 'kenso', erstelltAm: '2026-10-06T08:00:00.000Z', geaendertAm: '2026-10-06T08:00:00.000Z',
    ...extra,
  }
}

export const beispielSettings = { steuernummer: '12/345/67890', bankDetailsText: 'Finom Bank\nIBAN DE12 3456 7890 1234 5678 90\nBIC FNOMDEB2' }

/** Alle Zeichenketten in verschachtelten Objekten und Listen (flach gesammelt); Werte unter den Schlüsseln id und art sind keine Texte. */
export function alleTexte(wert, aus = []) {
  if (typeof wert === 'string') aus.push(wert)
  else if (Array.isArray(wert)) wert.forEach((e) => alleTexte(e, aus))
  else if (wert && typeof wert === 'object') {
    for (const [schluessel, e] of Object.entries(wert)) if (schluessel !== 'id' && schluessel !== 'art') alleTexte(e, aus)
  }
  return aus
}

test/auftraegePdfDaten.test.js (die Importe nennen schon die Namen aus Task 5; Task 5 hängt Tests an):

import { test } from 'node:test'
import assert from 'node:assert/strict'
import { useTestEnv } from './support/testEnv.js'
import { beispielAuftrag, beispielSettings } from './auftraegePdfHilfe.js'

useTestEnv({ appwriteUrl: 'http://127.0.0.1:1', stripeUrl: 'http://127.0.0.1:1' })
const { auftragPdfDaten, PDF_BESCHRIFTUNG, bereinigeTexte } = await import('../server/services/auftraege/pdf.js')
const { AB_TEXTE, WIDERRUFSBELEHRUNG_PROJEKT, WIDERRUFSFORMULAR } = await import('../server/services/auftraege/texte.js')
const { zahlungsplanText, aufwandText } = await import('../server/services/auftraege/auftragSicht.js')
const { AuftragError } = await import('../server/services/auftraege/fehler.js')
const { euroDe } = await import('../server/services/finance/format.js')

const JETZT = new Date('2026-10-06T10:00:00.000Z')
const NBSP = String.fromCodePoint(0xa0)
const FRUEHBEGINN_SATZ = 'Ohne Ihr ausdrückliches Verlangen beginnen wir erst nach Ablauf der Widerrufsfrist.' // V7: AB_TEXTE.termine bei Privatpersonen
const daten = (extra = {}, optionen = {}) => auftragPdfDaten(beispielAuftrag(extra), { settings: beispielSettings, jetzt: JETZT, ...optionen })
const aufwandAuftrag = { art: 'aufwand', positionen: [], summeCents: null, stundensatzCents: 10000, schaetzungMinuten: 600, zahlungsplan: { art: 'monatlich', prozent: null, text: '' } }

test('euroDe liefert Beträge mit geschütztem Leerzeichen vor dem €-Zeichen (Grundlage aller Betragsvergleiche hier)', () => {
  assert.equal(euroDe(60000), `600,00${NBSP}€`)
})

test('Festpreis: Kopf, Anschrift, Angaben und Positionen sind fertig formatiert', () => {
  const d = daten()
  assert.equal(d.vorschau, false)
  assert.equal(d.titel, AB_TEXTE.titel)
  assert.equal(d.nummer, 'AB-2026-0007')
  assert.equal(d.datum, '06.10.2026')
  assert.equal(d.kundennummer, 'K-1042')
  assert.equal(d.projekt, 'Neue Website Müller Bäckerei')
  assert.deepEqual(d.absender.zeilen, [
    'WEBklar GbR', 'Am Schwimmbad 10', '67722 Winnweiler', 'Telefon 0176 23726355', 'support@webklar.com', 'webklar.com', 'Steuernummer 12/345/67890',
  ])
  assert.equal(d.absender.rueckzeile, 'WEBklar GbR · Am Schwimmbad 10 · 67722 Winnweiler')
  assert.deepEqual(d.empfaenger, ['Müller Bäckerei GmbH', 'Anna Müller', 'Hauptstraße 12', '67722 Winnweiler'])
  assert.equal(d.einleitung, AB_TEXTE.einleitung({ datum: '05.10.2026', weg: 'telefonisch' }))
  assert.ok(d.einleitung.includes('05.10.2026') && d.einleitung.includes('telefonisch'))
  assert.equal(d.leistung.art, 'festpreis')
  assert.equal(d.leistung.ueberschrift, 'Leistungsumfang')
  assert.deepEqual(d.leistung.positionen, [
    { nr: '1', beschreibung: 'Gestaltung und Umsetzung der Website (5 Seiten)', menge: '1', einzelpreis: euroDe(60000), summe: euroDe(60000) },
    { nr: '2', beschreibung: 'Kontaktformular mit E-Mail-Versand', menge: '2', einzelpreis: euroDe(10000), summe: euroDe(20000) },
  ])
  assert.deepEqual(d.leistung.gesamt, { label: 'Gesamtpreis', betrag: euroDe(80000) })
  assert.equal(d.leistung.aufwandText, null)
  assert.equal(d.kleinunternehmer, 'Gemäß § 19 UStG wird keine Umsatzsteuer berechnet.')
  assert.deepEqual(PDF_BESCHRIFTUNG.spalten, ['Pos.', 'Beschreibung', 'Menge', 'Einzelpreis', 'Summe'])
})

test('Datum der AB ist der Berliner Tag von gesendetAm, ohne gesendetAm der heutige Berliner Tag', () => {
  assert.equal(daten({ gesendetAm: '2026-10-06T22:30:00.000Z' }).datum, '07.10.2026')
  assert.equal(daten({ gesendetAm: '2026-10-06T21:30:00+00:00' }).datum, '06.10.2026')
  assert.equal(daten({ gesendetAm: null }, { jetzt: new Date('2026-12-31T23:30:00.000Z') }).datum, '01.01.2027')
})

test('Aufwand: Aufwandsregel statt Positionen, keine Gesamtsumme', () => {
  const auftrag = beispielAuftrag(aufwandAuftrag)
  const d = auftragPdfDaten(auftrag, { settings: beispielSettings, jetzt: JETZT })
  assert.equal(d.leistung.art, 'aufwand')
  assert.deepEqual(d.leistung.positionen, [])
  assert.equal(d.leistung.gesamt, null)
  assert.equal(d.leistung.aufwandText, aufwandText(auftrag))
  assert.ok(d.leistung.aufwandText.includes(euroDe(10000)))
  assert.equal(d.kleinunternehmer, AB_TEXTE.kleinunternehmer)
})

test('Vorschau: Nummer „Entwurf“, heutiges Datum, Kennzeichnung; ohne Vorschau braucht die AB eine Nummer', () => {
  const entwurf = { nummer: '', gesendetAm: null }
  const d = daten(entwurf, { vorschau: true })
  assert.equal(d.vorschau, true)
  assert.equal(d.nummer, 'Entwurf')
  assert.equal(d.datum, '06.10.2026')
  assert.equal(d.beschriftung.entwurf, 'ENTWURF')
  assert.throws(() => daten(entwurf), (e) => e instanceof AuftragError && e.status === 409 && /Nummer/.test(e.message))
})

test('Anschrift: Firma und Name nur einmal, Land nur außerhalb Deutschlands, leere Teile entfallen', () => {
  const kunde = (extra) => ({ ...beispielAuftrag().kunde, ...extra })
  assert.deepEqual(daten({ kunde: kunde({ firma: 'Anna Müller' }) }).empfaenger, ['Anna Müller', 'Hauptstraße 12', '67722 Winnweiler'])
  assert.deepEqual(daten({ kunde: kunde({ land: 'Österreich', plz: '1010', ort: 'Wien' }) }).empfaenger, ['Müller Bäckerei GmbH', 'Anna Müller', 'Hauptstraße 12', '1010 Wien', 'Österreich'])
  assert.deepEqual(daten({ kunde: kunde({ firma: '', land: '', strasse: '' }) }).empfaenger, ['Anna Müller', '67722 Winnweiler'])
})

test('Fehlende Pflichtangaben und falsche Summe: AuftragError 409 mit Klartext statt kaputtem PDF', () => {
  const faelle = [
    [{ kunde: null }, /Kundendaten/],
    [{ titel: '   ' }, /Titel/],
    [{ auftragVom: '' }, /Datum der Absprache/],
    [{ auftragWeg: 'brieftaube' }, /Weg der Absprache/],
    [{ art: 'pauschal' }, /Art des Auftrags/],
    [{ zahlungsplan: null }, /Zahlungsplan/],
    [{ positionen: [], summeCents: 0 }, /Positionen/],
    [{ summeCents: 79999 }, /Summe der Positionen/],
    [{ ...aufwandAuftrag, stundensatzCents: null }, /Stundensatz/],
  ]
  for (const [extra, muster] of faelle) {
    assert.throws(() => daten(extra, { vorschau: true }), (e) => e instanceof AuftragError && e.status === 409 && muster.test(e.message), JSON.stringify(extra))
  }
})

• Step 2: Lauf, erwartet FAIL

Run: cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && timeout 900 nice -n 10 node --max-old-space-size=1024 --test test/auftraegePdfDaten.test.js Erwartet: FAIL („auftragPdfDaten is not a function“ bzw. „Cannot read properties of undefined“ für PDF_BESCHRIFTUNG).

• Step 3: Abschnitt „Daten“ in pdf.js schreiben (Felder bis kleinunternehmer)

Über dem Abschnitt „Schriften“ die Importe ergänzen: euroDe (../finance/format.js), berlinDate, formatDe (../finance/dates.js), AuftragError (./fehler.js), AGB_FASSUNG, AUFTRAG_ARTEN, AUFTRAG_WEGE, ZAHLUNGSPLAN_ARTEN (./konstanten.js), AB_TEXTE, ABSENDER, WIDERRUFSBELEHRUNG_PROJEKT, WIDERRUFSFORMULAR (./texte.js), aufwandText, zahlungsplanText (./auftragSicht.js). Dann // ===== 2. Daten ===== mit Signatur, Form und Regeln wie oben. Die Prüfung steht in einer eigenen Funktion pruefe(auftrag, vorschau), die Anschrift in empfaengerZeilen(kunde).

• Step 4: Lauf, erwartet PASS

Run: derselbe wie in Step 2. Erwartet: alle sieben Tests bestehen.

• Step 5: Commit

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4
git add server/services/auftraege/pdf.js test/auftraegePdfHilfe.js test/auftraegePdfDaten.test.js
git commit -m "AB-PDF: auftragPdfDaten mit Kopf, Anschrift, Positionen und Prüfung der Pflichtangaben

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

---

Task 5: auftragPdfDaten – Zahlung, Termine, AGB, Privatperson, Fuß, Vorschau, ersetzt

Files:

• Modify: server/services/auftraege/pdf.js
• Test: test/auftraegePdfDaten.test.js

Interfaces:

• Consumes: auftragPdfDaten aus Task 4; bereinigeTexte aus Task 3 (nur im Wächter-Test).
• Produces: die restlichen Felder von AuftragPdfDaten (Form in Task 4).

Regeln:

• abschnitte in dieser Reihenfolge: zahlung (ueberschrift „Zahlung“, text: zahlungsplanText(auftrag)), termine (nur wenn AB_TEXTE.termine({ start, fertig, privat }) einen nicht leeren Text liefert; start und fertig sind formatDe(startAm) bzw. formatDe(fertigBis) oder null, wenn leer; privat ist kunde.kundenart === 'privat' (V7): bei Privatpersonen liefert termine immer Text, auch ohne Daten, nämlich mit dem Satz „Ohne Ihr ausdrückliches Verlangen beginnen wir erst nach Ablauf der Widerrufsfrist.“; bei Unternehmen ohne Daten null, dann entfällt der Abschnitt; Überschrift „Termine“), mitwirkung (Überschrift „Mitwirkung und Abnahme“, text: AB_TEXTE.mitwirkung). Die Überschriften stehen in PDF_BESCHRIFTUNG.

• agb: AB_TEXTE.agb({ fassung: formatDe(auftrag.agbFassung || AGB_FASSUNG) }). gruss: AB_TEXTE.gruss.

• ersetzt: Option ersetzt = { nummer, datum } → AB_TEXTE.ersetzt({ nummer, datum: formatDe(datum) }), sonst null.

• widerruf: nur bei kunde.kundenart === 'privat' das Paar { belehrung: WIDERRUFSBELEHRUNG_PROJEKT, formular: WIDERRUFSFORMULAR } (unverändert, V7), sonst null. Die Frühbeginn-Erklärung selbst (das Verlangen des Kunden) gehört nicht ins PDF, sie steht auf der Bestätigungsseite; im PDF steht nur der Satz zum Beginn nach Ablauf der Widerrufsfrist im Abschnitt „Termine“ (siehe oben).

• fuss.bank: settings.bankDetailsText an Zeilenumbrüchen geteilt, Zeilen getrimmt, leere entfallen (ohne Text: []). fuss.kontakt: ['<name> · vertreten durch <vertretenDurch>', 'Telefon <telefon> · <email> · <web>'].

• Step 1: Failing Tests anhängen

An test/auftraegePdfDaten.test.js anhängen (der Wächter-Test besteht sofort; er schlägt erst an, wenn L7 später ein Zeichen außerhalb von Figtree einführt):

test('Zahlungsplan Anzahlung nennt Anzahlung und Rest mit Beträgen und das Zahlungsziel', () => {
  const auftrag = beispielAuftrag()
  const text = daten().abschnitte.find((a) => a.id === 'zahlung').text
  assert.equal(text, zahlungsplanText(auftrag))
  assert.equal(text.split(euroDe(40000)).length - 1, 2)
  assert.ok(text.includes('50') && text.includes('14'))
  const nachAufwand = beispielAuftrag(aufwandAuftrag)
  assert.equal(auftragPdfDaten(nachAufwand, { settings: beispielSettings, jetzt: JETZT }).abschnitte[0].text, zahlungsplanText(nachAufwand))
  const dreissig = beispielAuftrag({ zahlungsplan: { art: 'anzahlung', prozent: 30, text: '' }, zahlungszielTage: 30 })
  const text30 = auftragPdfDaten(dreissig, { settings: beispielSettings, jetzt: JETZT }).abschnitte[0].text
  assert.ok(text30.includes(euroDe(24000)) && text30.includes(euroDe(56000)) && text30.includes('30'))
})

test('Abschnitte: Zahlung, Termine (nur mit Datum), Mitwirkung und Abnahme; AGB-Satz mit Fassung', () => {
  const d = daten()
  assert.deepEqual(d.abschnitte.map((a) => [a.id, a.ueberschrift]), [['zahlung', 'Zahlung'], ['termine', 'Termine'], ['mitwirkung', 'Mitwirkung und Abnahme']])
  assert.equal(d.abschnitte[1].text, AB_TEXTE.termine({ start: '12.10.2026', fertig: '15.11.2026', privat: false }))
  assert.equal(d.abschnitte[2].text, AB_TEXTE.mitwirkung)
  assert.equal(d.agb, AB_TEXTE.agb({ fassung: '30.09.2026' }))
  assert.equal(daten({ startAm: '', fertigBis: '' }).abschnitte.some((a) => a.id === 'termine'), false)
  assert.equal(daten({ agbFassung: '' }).agb, AB_TEXTE.agb({ fassung: '30.09.2026' }), 'ohne agbFassung gilt AGB_FASSUNG')
  assert.equal(daten().gruss, AB_TEXTE.gruss)
})

test('Termine: Privatpersonen bekommen den Satz zum Beginn nach Ablauf der Widerrufsfrist, auch ohne Daten; Unternehmen nicht', () => {
  const privat = { kunde: { ...beispielAuftrag().kunde, firma: '', kundenart: 'privat' } }
  const termine = (d) => d.abschnitte.find((a) => a.id === 'termine')?.text
  const mitDaten = termine(daten(privat))
  assert.equal(mitDaten, AB_TEXTE.termine({ start: '12.10.2026', fertig: '15.11.2026', privat: true }))
  assert.ok(mitDaten.includes(FRUEHBEGINN_SATZ) && mitDaten.includes('12.10.2026') && mitDaten.includes('15.11.2026'))
  const ohneDaten = termine(daten({ ...privat, startAm: '', fertigBis: '' }))
  assert.equal(ohneDaten, AB_TEXTE.termine({ start: null, fertig: null, privat: true }))
  assert.ok(ohneDaten.includes(FRUEHBEGINN_SATZ), 'der Abschnitt „Termine“ steht auch ohne Start- und Fertigdatum')
  assert.equal(termine(daten()).includes(FRUEHBEGINN_SATZ), false)
  assert.equal(termine(daten({ startAm: '', fertigBis: '' })), undefined, 'Unternehmen ohne Daten: kein Abschnitt')
})

test('Privatperson: Widerrufsbelehrung und Muster-Widerrufsformular gehören dazu, bei Unternehmen nicht', () => {
  assert.equal(daten().widerruf, null)
  const privat = { kunde: { ...beispielAuftrag().kunde, firma: '', kundenart: 'privat' } }
  const d = daten(privat)
  assert.deepEqual(d.widerruf, { belehrung: WIDERRUFSBELEHRUNG_PROJEKT, formular: WIDERRUFSFORMULAR })
  assert.deepEqual(d.empfaenger, ['Anna Müller', 'Hauptstraße 12', '67722 Winnweiler'])
})

test('Ersetzte AB: Hinweis mit Nummer und Datum nur, wenn ersetzt übergeben wird', () => {
  assert.equal(daten().ersetzt, null)
  assert.equal(daten({}, { ersetzt: { nummer: 'AB-2026-0003', datum: '2026-10-01' } }).ersetzt, AB_TEXTE.ersetzt({ nummer: 'AB-2026-0003', datum: '01.10.2026' }))
})

test('Fuß: Bankverbindung zeilenweise, Kontakt; leere Angaben lassen ihre Zeilen weg', () => {
  const d = daten()
  assert.deepEqual(d.fuss.bank, ['Finom Bank', 'IBAN DE12 3456 7890 1234 5678 90', 'BIC FNOMDEB2'])
  assert.deepEqual(d.fuss.kontakt, ['WEBklar GbR · vertreten durch Kenso Grimm und Justin Klein', 'Telefon 0176 23726355 · support@webklar.com · webklar.com'])
  const leer = auftragPdfDaten(beispielAuftrag({ kunde: { ...beispielAuftrag().kunde, kundennummer: '' } }), { settings: {}, jetzt: JETZT })
  assert.deepEqual(leer.fuss.bank, [])
  assert.equal(leer.kundennummer, '')
  assert.equal(leer.absender.zeilen.at(-1), 'webklar.com', 'ohne Steuernummer entfällt die Zeile')
  assert.equal(auftragPdfDaten(beispielAuftrag(), { jetzt: JETZT }).fuss.bank.length, 0, 'ohne settings')
})

test('Wächter: alle Texte, die ins PDF kommen, haben ein Glyph in Figtree (die Ersetzung greift dort nie ein)', () => {
  const kunde = beispielAuftrag().kunde
  const faelle = [
    daten({ kunde: { ...kunde, kundenart: 'privat' } }, { ersetzt: { nummer: 'AB-2026-0003', datum: '2026-10-01' } }),
    daten({ kunde: { ...kunde, kundenart: 'privat' }, startAm: '', fertigBis: '' }),
    daten({ zahlungsplan: { art: 'nach_abnahme', prozent: null, text: '' } }),
    daten({ zahlungsplan: { art: 'frei', prozent: null, text: 'Zahlung in drei Raten.' } }),
    daten(aufwandAuftrag),
    daten({ ...aufwandAuftrag, schaetzungMinuten: null }),
  ]
  for (const d of faelle) assert.deepEqual(bereinigeTexte(d), d)
})

• Step 2: Lauf, erwartet FAIL

Run: cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && timeout 900 nice -n 10 node --max-old-space-size=1024 --test test/auftraegePdfDaten.test.js Erwartet: die Tests zu Zahlungsplan, Abschnitten, Termine, Privatperson, ersetzt und Fuß scheitern (Felder fehlen); der Wächter-Test besteht schon jetzt (er hält nur fest, dass die Texte lückenlos Glyphen haben); die sieben Tests aus Task 4 bestehen.

• Step 3: Restliche Felder in auftragPdfDaten ergänzen

Regeln wie oben.

• Step 4: Lauf, erwartet PASS

Run: derselbe wie in Step 2. Erwartet: alle vierzehn Tests bestehen.

• Step 5: Commit

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4
git add server/services/auftraege/pdf.js test/auftraegePdfDaten.test.js
git commit -m "AB-PDF: Zahlungsplan, Termine, AGB-Satz, Privatperson-Seiten, Fuß und Vorschau in den PDF-Daten

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

---

Task 6: Seitenaufteilung paginiere (rein, ohne pdfkit)

Files:

• Modify: server/services/auftraege/pdf.js (Abschnitt 3 „Layout“ anhängen: Maße, Farben, Stile, paginiere)
• Test: test/auftraegePdfLayout.test.js

Interfaces:

• Consumes: nichts (Test nutzt beispielAuftrag/auftragPdfDaten erst ab Task 7).
• Produces (pdf.js): exportiert SEITE, INHALT_BREITE, SPALTEN, BEREICHE (Werte unten, alle in pt) und paginiere(atome: Baustein[], bereiche = BEREICHE) → Seite[]; modulintern (nicht exportiert) FARBEN, ZELLEN_RAND, STIL, MASSE.

// Baustein: kleinste Einheit, wird nie geteilt (Höhe in pt)
{ id: string, typ: string, hoehe: number, abstandDavor: number, haengtAnNaechstem: boolean, umbruchDavor: boolean, kopf: Baustein | null }
// Seite
{ nummer: number /* ab 1 */, unten: number, posten: [{ atom: Baustein, y: number /* pt von der Oberkante */, wiederholt: boolean }] }

Maße und Stile (verbindliche Werte; pdfkit-Ränder bleiben 0, die Ränder stehen hier). Das Papier ist A4; unten bleiben 96 pt für den Fuß, Folgeseiten beginnen 40 pt tiefer als Seite 1 (Platz für den Kopf der Folgeseiten):

export const SEITE = Object.freeze({ breite: 595.28, hoehe: 841.89, links: 56.7, rechts: 56.7, oben: 48, unten: 96 })
export const INHALT_BREITE = SEITE.breite - SEITE.links - SEITE.rechts // 481.88
const FARBEN = Object.freeze({ tinte: '#111111', gedaempft: '#6b6964', linie: '#e8e6e0', linieDunkel: '#c9c6bd', flaeche: '#f7f6f3', entwurf: '#b42318' })
export const SPALTEN = Object.freeze([28, 237.88, 44, 86, 86]) // Pos., Beschreibung, Menge, Einzelpreis, Summe
const ZELLEN_RAND = 6
const STIL = Object.freeze({
  titel: { schrift: 'semibold', groesse: 22, lineGap: 0, farbe: FARBEN.tinte },
  projekt: { schrift: 'regular', groesse: 11, lineGap: 2, farbe: FARBEN.tinte },
  adresse: { schrift: 'regular', groesse: 10, lineGap: 2.5, farbe: FARBEN.tinte },
  ueberschrift: { schrift: 'semibold', groesse: 11, lineGap: 0, farbe: FARBEN.tinte },
  text: { schrift: 'regular', groesse: 9.5, lineGap: 2.5, farbe: FARBEN.tinte },
  klein: { schrift: 'regular', groesse: 8.5, lineGap: 2, farbe: FARBEN.gedaempft },
  tabellenkopf: { schrift: 'semibold', groesse: 8.5, lineGap: 0, farbe: FARBEN.gedaempft },
  summe: { schrift: 'semibold', groesse: 10.5, lineGap: 0, farbe: FARBEN.tinte },
  fussLabel: { schrift: 'semibold', groesse: 7.5, lineGap: 1.5, farbe: FARBEN.gedaempft },
  fuss: { schrift: 'regular', groesse: 7.5, lineGap: 1.5, farbe: FARBEN.gedaempft },
})
const MASSE = Object.freeze({
  kopfHoehe: 22, summeHoehe: 30, kastenRand: 8, adresseBreite: 250, infoX: 340, infoZeile: 15,
  rueckY: 80, adresseY: 94, // Rücksendezeile und Anschriftfeld relativ zur Oberkante des Briefkopfs (DIN 5008, Form B)
  fussHoehe: 82, folgeKopf: 40,
})
const SICHERHEIT = 1
export const BEREICHE = Object.freeze({
  erste: { oben: SEITE.oben, unten: SEITE.hoehe - SEITE.unten - SICHERHEIT },
  folge: { oben: SEITE.oben + MASSE.folgeKopf, unten: SEITE.hoehe - SEITE.unten - SICHERHEIT },
})

paginiere setzt voraus: Bausteine mit haengtAnNaechstem bilden mit ihrem Nachfolger eine Kette; eine Kette steht ganz auf einer Seite, wenn sie auf eine leere Folgeseite passt, sonst wird sie zwischen Bausteinen getrennt (kein Endlosschleifen-Risiko: ein zu hoher Baustein steht allein ganz oben). umbruchDavor beginnt eine neue Seite, aber nie eine leere. abstandDavor entfällt am Seitenanfang. Beginnt eine Folgeseite mit einem Baustein, der einen kopf hat (Tabellenzeile), steht dieser Kopf als wiederholter Posten (wiederholt: true) davor. Ohne Bausteine gibt es eine leere Seite. Der Algorithmus (bestimmt weder Signatur noch Test eindeutig):

export function paginiere(atome, bereiche = BEREICHE) {
  const seiten = []
  const folgeHoehe = bereiche.folge.unten - bereiche.folge.oben
  let seite
  let y
  const neueSeite = () => {
    const bereich = seiten.length === 0 ? bereiche.erste : bereiche.folge
    seite = { nummer: seiten.length + 1, posten: [], unten: bereich.unten }
    seiten.push(seite)
    y = bereich.oben
  }
  const frisch = () => seite.posten.every((p) => p.wiederholt)
  const abstand = (a) => (frisch() ? 0 : a.abstandDavor)
  neueSeite()
  for (let i = 0; i < atome.length; ) {
    let j = i
    while (j < atome.length - 1 && atome[j].haengtAnNaechstem) j += 1
    const kette = atome.slice(i, j + 1)
    i = j + 1
    if (kette[0].umbruchDavor && !frisch()) neueSeite()
    const bedarf = kette.reduce((summe, a, k) => summe + (k === 0 ? 0 : a.abstandDavor) + a.hoehe, 0)
    const kopfHoehe = kette[0].kopf ? kette[0].kopf.hoehe : 0
    if (!frisch() && y + abstand(kette[0]) + bedarf > seite.unten && bedarf + kopfHoehe <= folgeHoehe) neueSeite()
    for (const a of kette) {
      if (!frisch() && y + abstand(a) + a.hoehe > seite.unten) neueSeite()
      if (seite.nummer > 1 && a.kopf && seite.posten.length === 0) {
        seite.posten.push({ atom: a.kopf, y, wiederholt: true })
        y += a.kopf.hoehe
      }
      y += abstand(a)
      seite.posten.push({ atom: a, y, wiederholt: false })
      y += a.hoehe
    }
  }
  return seiten
}

• Step 1: Failing Tests schreiben

test/auftraegePdfLayout.test.js (die Importe nennen baueAtome und die Testhilfen schon, Task 7 hängt Tests an):

import { test } from 'node:test'
import assert from 'node:assert/strict'
import { useTestEnv } from './support/testEnv.js'
import { beispielAuftrag, beispielSettings } from './auftraegePdfHilfe.js'

useTestEnv({ appwriteUrl: 'http://127.0.0.1:1', stripeUrl: 'http://127.0.0.1:1' })
const { auftragPdfDaten, paginiere, baueAtome, BEREICHE, SEITE, SPALTEN, INHALT_BREITE } = await import('../server/services/auftraege/pdf.js')

// Kleine Seiten: erste Seite 0–200 pt, Folgeseiten 20–200 pt
const SEITEN = { erste: { oben: 0, unten: 200 }, folge: { oben: 20, unten: 200 } }
const baustein = (id, hoehe, extra = {}) => ({ id, typ: 'absatz', hoehe, abstandDavor: 0, haengtAnNaechstem: false, umbruchDavor: false, kopf: null, ...extra })
const lage = (seiten) => seiten.map((s) => s.posten.map((p) => `${p.atom.id}${p.wiederholt ? '*' : ''}@${p.y}`))

test('Maße: A4, Inhaltsbreite und Spaltenbreiten passen zusammen', () => {
  assert.equal(SEITE.breite, 595.28)
  assert.equal(SEITE.hoehe, 841.89)
  assert.ok(Math.abs(INHALT_BREITE - 481.88) < 1e-9)
  assert.ok(Math.abs(SPALTEN.reduce((a, b) => a + b, 0) - INHALT_BREITE) < 1e-9)
  assert.ok(BEREICHE.erste.oben < BEREICHE.folge.oben && BEREICHE.erste.unten === BEREICHE.folge.unten)
  assert.ok(BEREICHE.erste.unten < SEITE.hoehe - 80, 'Platz für den Fuß bleibt frei')
})

test('paginiere: alles passt auf eine Seite, Abstände nur zwischen Bausteinen', () => {
  const seiten = paginiere([baustein('a', 30, { abstandDavor: 9 }), baustein('b', 20, { abstandDavor: 8 }), baustein('c', 10, { abstandDavor: 8 })], SEITEN)
  assert.deepEqual(lage(seiten), [['a@0', 'b@38', 'c@66']])
  assert.deepEqual(paginiere([], SEITEN).map((s) => s.posten), [[]], 'auch ohne Inhalt gibt es eine Seite')
})

test('paginiere: was nicht mehr passt, beginnt die nächste Seite ohne Abstand davor', () => {
  const seiten = paginiere([baustein('a', 170), baustein('b', 40, { abstandDavor: 5 }), baustein('c', 40, { abstandDavor: 5 })], SEITEN)
  assert.deepEqual(lage(seiten), [['a@0'], ['b@20', 'c@65']])
  assert.deepEqual(seiten.map((s) => s.nummer), [1, 2])
})

test('paginiere: Überschrift (haengtAnNaechstem) bleibt bei ihrem Absatz', () => {
  const seiten = paginiere([baustein('a', 150), baustein('kopf', 15, { abstandDavor: 5, haengtAnNaechstem: true }), baustein('text', 40)], SEITEN)
  assert.deepEqual(lage(seiten), [['a@0'], ['kopf@20', 'text@35']])
})

test('paginiere: umbruchDavor beginnt eine neue Seite, aber nie eine leere', () => {
  assert.deepEqual(lage(paginiere([baustein('a', 30), baustein('b', 30, { umbruchDavor: true })], SEITEN)), [['a@0'], ['b@20']])
  assert.deepEqual(lage(paginiere([baustein('a', 30, { umbruchDavor: true })], SEITEN)), [['a@0']])
  assert.deepEqual(lage(paginiere([baustein('a', 200), baustein('b', 30, { umbruchDavor: true })], SEITEN)), [['a@0'], ['b@20']])
})

const tabelle = (zeilen, extra = {}) => {
  const kopf = baustein('kopf', 20, { typ: 'tabellenkopf', haengtAnNaechstem: true })
  const rows = Array.from({ length: zeilen }, (_, i) => baustein(`z${i + 1}`, 30, { typ: 'zeile', kopf, haengtAnNaechstem: i === zeilen - 1 && extra.mitSumme }))
  return [kopf, ...rows, ...(extra.mitSumme ? [baustein('summe', 30, { haengtAnNaechstem: true }), baustein('hinweis', 10)] : [])]
}

test('paginiere: lange Tabelle läuft über mehrere Seiten, der Kopf wiederholt sich, keine Zeile wird geteilt', () => {
  const seiten = paginiere(tabelle(20), SEITEN)
  assert.deepEqual(lage(seiten).map((s) => s.length), [7, 6, 6, 5], 'Seite 1: Kopf + 6 Zeilen; Folgeseiten: wiederholter Kopf + je 5 Zeilen, Rest auf der letzten')
  assert.equal(seiten.length, 4)
  for (const seite of seiten.slice(1)) {
    assert.equal(seite.posten[0].atom.id, 'kopf')
    assert.equal(seite.posten[0].wiederholt, true)
    assert.equal(seite.posten[0].y, 20)
  }
  const zeilen = seiten.flatMap((s) => s.posten.filter((p) => !p.wiederholt).map((p) => p.atom.id))
  assert.deepEqual(zeilen, ['kopf', ...Array.from({ length: 20 }, (_, i) => `z${i + 1}`)])
  for (const seite of seiten) for (const p of seite.posten) assert.ok(p.y + p.atom.hoehe <= seite.unten, `${p.atom.id} ragt über die Seite`)
})

test('paginiere: letzte Zeile, Summe und Hinweis bleiben zusammen, auch wenn die Zeile allein noch gepasst hätte', () => {
  // Seite 1: Kopf (20) + 6 Zeilen (180) = 200 – Zeile 6 ist die letzte und hängt an Summe und Hinweis
  const seiten = paginiere(tabelle(6, { mitSumme: true }), SEITEN)
  assert.deepEqual(lage(seiten), [['kopf@0', 'z1@20', 'z2@50', 'z3@80', 'z4@110', 'z5@140'], ['kopf*@20', 'z6@40', 'summe@70', 'hinweis@100']])
})

test('paginiere: Kette größer als eine Seite wird zwischen Bausteinen getrennt, zu hoher Baustein steht allein', () => {
  const kette = [baustein('a', 120, { haengtAnNaechstem: true }), baustein('b', 120, { haengtAnNaechstem: true }), baustein('c', 120)]
  assert.deepEqual(lage(paginiere(kette, SEITEN)), [['a@0'], ['b@20'], ['c@20']])
  assert.deepEqual(lage(paginiere([baustein('a', 50), baustein('riesig', 500), baustein('b', 50)], SEITEN)), [['a@0'], ['riesig@20'], ['b@20']])
})

• Step 2: Lauf, erwartet FAIL

Run: cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && timeout 900 nice -n 10 node --max-old-space-size=1024 --test test/auftraegePdfLayout.test.js Erwartet: FAIL („Cannot read properties of undefined“ bzw. „paginiere is not a function“).

• Step 3: Abschnitt „Layout“ in pdf.js schreiben

// ===== 3. Layout (rein, ohne pdfkit): Maße, Bausteine, Seitenaufteilung ===== mit den Konstanten und paginiere wie oben (Werte und Algorithmus sind verbindlich).

• Step 4: Lauf, erwartet PASS

Run: derselbe wie in Step 2. Erwartet: alle acht Tests bestehen.

• Step 5: Commit

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4
git add server/services/auftraege/pdf.js test/auftraegePdfLayout.test.js
git commit -m "AB-PDF: Maße und Seitenaufteilung mit wiederholtem Tabellenkopf

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

---

Task 7: Bausteine baueAtome

Files:

• Modify: server/services/auftraege/pdf.js (Abschnitt 3)
• Test: test/auftraegePdfLayout.test.js

Interfaces:

• Consumes: AuftragPdfDaten (Tasks 4 und 5), STIL, MASSE, SPALTEN, ZELLEN_RAND, INHALT_BREITE (Task 6).
• Produces: baueAtome(daten: AuftragPdfDaten, messe: (text: string, stil: object, breite: number) => number) → Baustein[] in Zeichenreihenfolge. messe liefert die Texthöhe in pt (in erzeugeAuftragPdf über doc.heightOfString, im Test eine Attrappe). Die Funktion ist rein.

Bausteine (typ und Nutzlast sind der Vertrag mit dem Zeichnen in Abschnitt 4; Höhe, Abstand und Kette wie angegeben):

id	typ und Nutzlast	Höhe	abstandDavor	haengtAnNaechstem
briefkopf	briefkopf, masse: { titelY, projektY, projektHoehe, infoZeilen }	projektY + projektHoehe + 4	0	ja
einleitung	absatz, text, stil: 'text'	messe(text, STIL.text, INHALT_BREITE)	8	nein
leistung	ueberschrift, text	messe(text, STIL.ueberschrift, INHALT_BREITE) + 5	14	ja
tabellenkopf (Festpreis)	tabellenkopf, spalten: beschriftung.spalten	MASSE.kopfHoehe	0	ja
zeile-1 … zeile-n	zeile, zelle (die Position), kopf (der Baustein tabellenkopf)	max(messe(beschreibung, STIL.text, SPALTEN[1] − 2 × ZELLEN_RAND), messe('X', STIL.text, SPALTEN[1])) + 2 × ZELLEN_RAND	0	nur die letzte Zeile
summe (Festpreis)	summe, label, betrag	MASSE.summeHoehe	0	ja
aufwand (statt Tabelle)	absatz, text: aufwandText, stil: 'text', kasten: true	messe(text, STIL.text, INHALT_BREITE − 2 × MASSE.kastenRand) + 2 × MASSE.kastenRand	0	ja
kleinunternehmer	absatz, stil: 'klein'	messe(text, STIL.klein, INHALT_BREITE)	8	nein
je Abschnitt <id>-kopf und <id>	ueberschrift (wie leistung) und absatz (stil: 'text')	wie leistung bzw. einleitung	14 bzw. 0	Kopf ja, Text nein
agb	absatz, stil: 'text'	Textblock	12	nein
ersetzt (nur wenn Text)	absatz, stil: 'text'	Textblock	8	nein
gruss	absatz, stil: 'text'	Textblock	14	nein
widerruf-titel (nur Privatperson)	ueberschrift, stil: 'titel'	messe(titel, STIL.titel, INHALT_BREITE) + 8	0	ja; umbruchDavor: true
widerruf-<i>-kopf, widerruf-<i>-<k>	ueberschrift bzw. absatz (stil: 'text')	wie oben	14 bzw. 0 (erster Absatz) / 5 (weitere)	Kopf ja
formular-titel	ueberschrift (Stil STIL.ueberschrift)	messe(…) + 5	20	ja
formular-einleitung	absatz, stil: 'klein'	Textblock	0	ja
formular-<i> je Zeile	absatz, stil: 'text'	Textblock	8	ja, außer bei der letzten Zeile

briefkopf.masse: infoZeilen = [[Nummer, nummer], [Datum, datum]] plus [Kundennummer, kundennummer] nur bei nicht leerer Kundennummer (Beschriftungen aus daten.beschriftung); adresseHoehe = messe(empfaenger.join('\n'), STIL.adresse, MASSE.adresseBreite); blockEnde = MASSE.adresseY + max(adresseHoehe, infoZeilen.length × MASSE.infoZeile); titelY = blockEnde + 22; projektY = titelY + STIL.titel.groesse × 1.2 + 6; projektHoehe = messe('<Projekt-Beschriftung>: <projekt>', STIL.projekt, INHALT_BREITE). Jeder Baustein hat zusätzlich die Standardfelder aus Task 6 (abstandDavor: 0, haengtAnNaechstem: false, umbruchDavor: false, kopf: null, wo nichts anderes steht). Die Reihenfolge ist die der Tabelle von oben nach unten; das Formular steht hinter der Belehrung. Die ganze Kette des Formulars (formular-titel bis zur letzten Zeile) bleibt dadurch zusammen.

• Step 1: Failing Tests anhängen

An test/auftraegePdfLayout.test.js anhängen:

// Messfunktion ohne pdfkit: 10 pt je angefangene 60 Zeichen
const messe = (text) => 10 * Math.max(1, Math.ceil(String(text).length / 60))
const bausteine = (extra = {}, optionen = {}) => baueAtome(auftragPdfDaten(beispielAuftrag(extra), { settings: beispielSettings, ...optionen }), messe)
const ids = (atome) => atome.map((a) => a.id)

test('baueAtome Festpreis: Reihenfolge, Zeilenhöhen und Zusammenhalt der Tabelle', () => {
  const atome = bausteine()
  assert.deepEqual(ids(atome), [
    'briefkopf', 'einleitung', 'leistung', 'tabellenkopf', 'zeile-1', 'zeile-2', 'summe', 'kleinunternehmer',
    'zahlung-kopf', 'zahlung', 'termine-kopf', 'termine', 'mitwirkung-kopf', 'mitwirkung', 'agb', 'gruss',
  ])
  const nach = (id) => atome.find((a) => a.id === id)
  assert.equal(nach('briefkopf').typ, 'briefkopf')
  assert.ok(nach('briefkopf').hoehe > 150)
  assert.equal(nach('briefkopf').masse.infoZeilen.length, 3)
  assert.equal(nach('zeile-1').hoehe, 10 + 12, 'eine Zeile Text plus 2 × 6 pt Rand')
  assert.deepEqual([nach('leistung'), nach('tabellenkopf'), nach('zeile-1'), nach('zeile-2'), nach('summe'), nach('kleinunternehmer')].map((a) => a.haengtAnNaechstem), [true, true, false, true, true, false])
  assert.equal(nach('zeile-1').kopf, nach('tabellenkopf'))
  assert.equal(nach('zeile-2').kopf, nach('tabellenkopf'))
  assert.equal(nach('summe').label, 'Gesamtpreis')
  assert.ok(atome.every((a) => a.hoehe > 0 && Number.isFinite(a.hoehe)))
})

test('baueAtome Aufwand, ersetzt und Privatperson: nur die passenden Bausteine', () => {
  const aufwand = bausteine({ art: 'aufwand', positionen: [], summeCents: null, stundensatzCents: 10000, schaetzungMinuten: 600, zahlungsplan: { art: 'monatlich', prozent: null, text: '' } })
  assert.ok(ids(aufwand).includes('aufwand') && !ids(aufwand).includes('tabellenkopf') && !ids(aufwand).includes('summe'))
  assert.equal(aufwand.find((a) => a.id === 'aufwand').kasten, true)
  const mitErsetzt = bausteine({}, { ersetzt: { nummer: 'AB-2026-0003', datum: '2026-10-01' } })
  assert.ok(ids(mitErsetzt).indexOf('ersetzt') > ids(mitErsetzt).indexOf('agb') && ids(mitErsetzt).indexOf('ersetzt') < ids(mitErsetzt).indexOf('gruss'))
  assert.equal(ids(bausteine()).some((id) => /^(widerruf|formular)/.test(id)), false)
  const privat = bausteine({ kunde: { ...beispielAuftrag().kunde, kundenart: 'privat' } })
  const titel = privat.find((a) => a.id === 'widerruf-titel')
  assert.equal(titel.umbruchDavor, true)
  assert.ok(ids(privat).indexOf('formular-titel') > ids(privat).indexOf('widerruf-titel'))
  assert.equal(privat.find((a) => a.id === 'formular-titel').haengtAnNaechstem, true)
  assert.equal(privat.at(-1).haengtAnNaechstem, false)
})

test('20 Positionen mit je 200 Zeichen ohne Leerzeichen: alle Zeilen da, mehrere Seiten, Tabellenkopf auf jeder Folgeseite', () => {
  const positionen = Array.from({ length: 20 }, (_, i) => ({ beschreibung: 'X'.repeat(200), menge: i + 1, einzelpreisCents: 1000 }))
  const summe = positionen.reduce((s, p) => s + p.menge * p.einzelpreisCents, 0)
  const seiten = paginiere(bausteine({ positionen, summeCents: summe }), BEREICHE)
  assert.ok(seiten.length >= 2)
  const zeilen = seiten.flatMap((s) => s.posten.filter((p) => p.atom.typ === 'zeile').map((p) => p.atom.id))
  assert.deepEqual(zeilen, Array.from({ length: 20 }, (_, i) => `zeile-${i + 1}`))
  for (const seite of seiten.slice(1)) {
    const ersteZeile = seite.posten.findIndex((p) => p.atom.typ === 'zeile')
    if (ersteZeile >= 0) assert.equal(seite.posten[0].atom.typ, 'tabellenkopf', `Seite ${seite.nummer} beginnt mit dem Tabellenkopf`)
  }
  const letzte = seiten.at(-1).posten.map((p) => p.atom.id)
  assert.ok(letzte.indexOf('summe') > letzte.indexOf('zeile-20'), 'Summe steht bei der letzten Zeile')
  for (const seite of seiten) for (const p of seite.posten) assert.ok(p.y + p.atom.hoehe <= seite.unten + 1e-9)
})

test('lange Widerrufsbelehrung: beginnt auf einer neuen Seite, das Formular bleibt zusammen', () => {
  const absatz = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. '.repeat(12)
  const d = auftragPdfDaten(beispielAuftrag({ kunde: { ...beispielAuftrag().kunde, kundenart: 'privat' } }), { settings: beispielSettings })
  d.widerruf = { ...d.widerruf, belehrung: { titel: 'Widerrufsbelehrung', abschnitte: Array.from({ length: 6 }, (_, i) => ({ ueberschrift: `Abschnitt ${i + 1}`, absaetze: [absatz, absatz] })) } }
  const seiten = paginiere(baueAtome(d, messe), BEREICHE)
  const seiteVon = (id) => seiten.find((s) => s.posten.some((p) => p.atom.id === id)).nummer
  assert.ok(seiten.length >= 4)
  assert.ok(seiteVon('widerruf-titel') >= 2)
  assert.equal(seiten[seiteVon('widerruf-titel') - 1].posten.find((p) => !p.wiederholt).atom.id, 'widerruf-titel', 'Belehrung beginnt oben auf einer neuen Seite')
  const formular = seiten.flatMap((s) => s.posten.filter((p) => p.atom.id.startsWith('formular')).map(() => s.nummer))
  assert.ok(formular.length >= 2 && new Set(formular).size === 1, 'alle Zeilen des Formulars stehen auf derselben Seite')
  for (const seite of seiten) for (const p of seite.posten) assert.ok(p.y + p.atom.hoehe <= seite.unten + 1e-9)
})

• Step 2: Lauf, erwartet FAIL

Run: cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && timeout 900 nice -n 10 node --max-old-space-size=1024 --test test/auftraegePdfLayout.test.js Erwartet: die vier neuen Tests scheitern („baueAtome is not a function“), die acht aus Task 6 bestehen.

• Step 3: baueAtome in Abschnitt 3 von pdf.js ergänzen (exportiert)

Signatur, Tabelle und masse-Regeln wie oben.

• Step 4: Lauf, erwartet PASS

Run: derselbe wie in Step 2. Erwartet: alle zwölf Tests bestehen.

• Step 5: Commit

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4
git add server/services/auftraege/pdf.js test/auftraegePdfLayout.test.js
git commit -m "AB-PDF: Bausteine der Auftragsbestätigung mit Höhen und Zusammenhalt

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

---

Task 8: Textleser für PDF-Tests

Files:

• Modify: test/auftraegePdfHilfe.js (Import ergänzen, seitenZahl und leseSeiten anhängen)
• Test: test/auftraegePdfLeser.test.js

Interfaces:

• Consumes: ladeSchriften() (Task 2; der Test baut mit pdfkit direkt ein kleines PDF, unabhängig vom AB-Code).
• Produces (Testhilfe): seitenZahl(pdf: Buffer) → number (zählt /Type /Page, nicht /Type /Pages); leseSeiten(pdf: Buffer) → string[][] (je Seite die Textzeilen in Zeichenreihenfolge, eine Zeile je text()-Aufruf bzw. je umbrochene Zeile).

Warum ein eigener Leser: auf dem Host gibt es kein pdftotext, neue Abhängigkeiten sind verboten. pdfkit schreibt eingebettete Schriften als Glyphnummern der Teilmenge ([<0001 0002> -20 <0003>] TJ zwischen BT und ET); die Rückübersetzung steht in der ToUnicode-Tabelle der Schrift (bfrange-Einträge mit je einem Eintrag pro Glyphnummer). Der Leser sammelt alle Objekte (Ströme mit zlib.inflateSync, wenn /FlateDecode), baut je Schrift die Tabelle, ordnet die Schriftnamen der Seitenressourcen (/F1) den Schriftobjekten zu und liest je Seite den Inhaltsstrom. Er kennt nur, was pdfkit schreibt.

• Step 1: Failing Test schreiben

test/auftraegePdfLeser.test.js:

import { test } from 'node:test'
import assert from 'node:assert/strict'
import PDFDocument from 'pdfkit'
import { useTestEnv } from './support/testEnv.js'
import { leseSeiten, seitenZahl } from './auftraegePdfHilfe.js'

useTestEnv({ appwriteUrl: 'http://127.0.0.1:1', stripeUrl: 'http://127.0.0.1:1' })
const { ladeSchriften } = await import('../server/services/auftraege/pdf.js')

// Prüft die Testhilfe selbst an einem kleinen, direkt mit pdfkit gebauten PDF (unabhängig vom AB-Code)
function kleinesPdf(komprimieren) {
  const { regular, semibold } = ladeSchriften()
  const doc = new PDFDocument({ size: 'A4', compress: komprimieren, info: { CreationDate: new Date('2026-10-06T10:00:00.000Z') } })
  doc.registerFont('Figtree', regular)
  doc.registerFont('Figtree-SemiBold', semibold)
  const teile = []
  doc.on('data', (teil) => teile.push(teil))
  const fertig = new Promise((resolve) => doc.on('end', () => resolve(Buffer.concat(teile))))
  doc.font('Figtree').fontSize(12).text(`Müller & Söhne – ß € ${String.fromCodePoint(0x2212)}5`, 50, 50, { lineBreak: false })
  doc.font('Figtree-SemiBold').fontSize(12).text('Zweite Zeile „fett“', 50, 80, { lineBreak: false })
  doc.addPage().font('Figtree').fontSize(12).text('Seite zwei', 50, 50, { lineBreak: false })
  doc.end()
  return fertig
}

test('leseSeiten und seitenZahl: Text je Seite aus einem pdfkit-PDF, komprimiert und unkomprimiert', async () => {
  for (const komprimieren of [true, false]) {
    const pdf = await kleinesPdf(komprimieren)
    assert.equal(seitenZahl(pdf), 2)
    assert.deepEqual(leseSeiten(pdf), [[`Müller & Söhne – ß € ${String.fromCodePoint(0x2212)}5`, 'Zweite Zeile „fett“'], ['Seite zwei']])
  }
})

• Step 2: Lauf, erwartet FAIL

Run: cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && timeout 900 nice -n 10 node --max-old-space-size=1024 --test test/auftraegePdfLeser.test.js Erwartet: FAIL (leseSeiten und seitenZahl werden von der Testhilfe nicht exportiert).

• Step 3: Testhilfe ergänzen

In test/auftraegePdfHilfe.js ganz oben import { inflateSync } from 'node:zlib' einfügen und unten anhängen:

/** Anzahl Seiten eines PDFs (Seitenobjekte, nicht der Seitenbaum). */
export const seitenZahl = (pdf) => (pdf.toString('latin1').match(/\/Type \/Page(?![s\w])/g) || []).length

/**
 * Text aus einem mit pdfkit erzeugten PDF (eingebettete Schriften, Identity-H, ToUnicode), je Seite eine Liste
 * von Textzeilen in Zeichenreihenfolge. Nur für Tests: kennt genau das, was pdfkit schreibt.
 */
export function leseSeiten(pdf) {
  const s = pdf.toString('latin1')
  const objekte = new Map()
  const re = /(\d+) 0 obj\n/g
  let m
  while ((m = re.exec(s))) {
    const start = m.index + m[0].length
    const ende = s.indexOf('\nendobj', start)
    const koerper = s.slice(start, ende)
    const strom = koerper.indexOf('\nstream\n')
    let dict = koerper
    let daten = null
    if (strom >= 0) {
      dict = koerper.slice(0, strom)
      const laenge = Number(/\/Length (\d+)/.exec(dict)[1])
      daten = pdf.subarray(start + strom + 8, start + strom + 8 + laenge)
      if (/\/Filter \/FlateDecode/.test(dict)) daten = inflateSync(daten)
    }
    objekte.set(Number(m[1]), { dict, daten })
    re.lastIndex = ende
  }
  const tabellen = new Map()
  for (const [id, o] of objekte) {
    const tu = /\/ToUnicode (\d+) 0 R/.exec(o.dict)
    if (!/\/Subtype \/Type0/.test(o.dict) || !tu) continue
    const tabelle = []
    for (const r of objekte.get(Number(tu[1])).daten.toString('latin1').matchAll(/<([0-9a-f]{4})> <([0-9a-f]{4})> \[([^\]]*)\]/g)) {
      let i = parseInt(r[1], 16)
      for (const e of r[3].matchAll(/<([0-9a-f ]+)>/g)) tabelle[i++] = e[1].split(' ').map((h) => String.fromCharCode(parseInt(h, 16))).join('')
    }
    tabellen.set(id, tabelle)
  }
  const schriftNachName = new Map()
  for (const o of objekte.values()) {
    if (!/\/Font <</.test(o.dict)) continue
    for (const f of o.dict.matchAll(/\/(F\d+) (\d+) 0 R/g)) schriftNachName.set(f[1], tabellen.get(Number(f[2])))
  }
  const seiten = []
  for (const o of objekte.values()) {
    if (!/\/Type \/Page(?![s\w])/.test(o.dict)) continue
    const inhalt = objekte.get(Number(/\/Contents (\d+) 0 R/.exec(o.dict)[1])).daten.toString('latin1')
    const zeilen = []
    for (const bt of inhalt.matchAll(/BT\n([\s\S]*?)\nET/g)) {
      const tabelle = schriftNachName.get(/\/(F\d+) [\d.]+ Tf/.exec(bt[1])?.[1])
      let text = ''
      for (const tj of bt[1].matchAll(/\[([^\]]*)\] TJ/g)) {
        for (const h of tj[1].matchAll(/<([0-9a-f]+)>/g)) {
          for (let i = 0; i < h[1].length; i += 4) text += tabelle[parseInt(h[1].slice(i, i + 4), 16)] ?? '\u{FFFD}'
        }
      }
      zeilen.push(text)
    }
    seiten.push(zeilen)
  }
  return seiten
}

• Step 4: Lauf, erwartet PASS

Run: derselbe wie in Step 2. Erwartet: der eine Test besteht (komprimiert und unkomprimiert).

• Step 5: Commit

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4
git add test/auftraegePdfHilfe.js test/auftraegePdfLeser.test.js
git commit -m "AB-PDF: Textleser für PDF-Tests (ToUnicode, nur Node-Bordmittel)

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

---

Task 9: PDF zeichnen – erzeugeAuftragPdf

Files:

• Modify: server/services/auftraege/pdf.js (Importe oben ergänzen; Abschnitt 4 „Zeichnen“ und Abschnitt 5 „Ablauf“ anhängen)
• Test: test/auftraegePdf.test.js

Interfaces:

• Consumes: auftragPdfDaten (Tasks 4 und 5), bereinigeTexte, ladeSchriften (Tasks 2 und 3), baueAtome, paginiere, BEREICHE und die Maße (Tasks 6 und 7), Testhilfe leseSeiten, seitenZahl, alleTexte, beispielAuftrag (Tasks 4 und 8).
• Produces (pdf.js, Abschnitt 4, modulintern): setzeStil(doc, stil) → doc (setzt Schrift Figtree bzw. Figtree-SemiBold nach stil.schrift, Größe und Füllfarbe) und zeichneAuftrag(doc, daten: AuftragPdfDaten, seiten: Seite[], assets: ladeSchriften()) → void.
• Produces (pdf.js, Abschnitt 5, exportiert): erzeugeAuftragPdf(auftrag: Auftrag, { settings, vorschau = false, jetzt = new Date() } = {}) → Promise<Buffer>. Wirft AuftragError (409) wie auftragPdfDaten; PDF-Fehler anderer Art werden unverändert weitergereicht.

Ablauf von erzeugeAuftragPdf (Algorithmus, den Signatur und Tests nicht bestimmen; neuer Import am Kopf von pdf.js: import PDFDocument from 'pdfkit'):

/** Das AB-PDF (A4) als Buffer. */
export async function erzeugeAuftragPdf(auftrag, { settings, vorschau = false, jetzt = new Date() } = {}) {
  const daten = bereinigeTexte(auftragPdfDaten(auftrag, { settings, vorschau, jetzt }))
  const assets = ladeSchriften()
  const doc = new PDFDocument({
    size: 'A4', margins: { top: 0, bottom: 0, left: 0, right: 0 }, lang: 'de-DE', displayTitle: true,
    info: {
      Title: `${daten.titel} ${daten.nummer}`, Author: 'WEBklar GbR', Subject: daten.projekt, Producer: 'WEBklar Kundenportal',
      CreationDate: new Date(auftrag.gesendetAm || jetzt),
    },
  })
  doc.registerFont('Figtree', assets.regular)
  doc.registerFont('Figtree-SemiBold', assets.semibold)
  const teile = []
  doc.on('data', (teil) => teile.push(teil))
  const fertig = new Promise((resolve, reject) => {
    doc.on('end', () => resolve(Buffer.concat(teile)))
    doc.on('error', reject)
  })
  fertig.catch(() => {}) // scheitert das Zeichnen zuerst, soll das verworfene Versprechen nichts auslösen
  try {
    const messe = (text, stil, breite) => {
      setzeStil(doc, stil)
      return doc.heightOfString(text, { width: breite, lineGap: stil.lineGap })
    }
    const seiten = paginiere(baueAtome(daten, messe), BEREICHE)
    zeichneAuftrag(doc, daten, seiten, assets)
    doc.end()
  } catch (fehler) {
    doc.destroy()
    throw fehler
  }
  return fertig
}

Zeichenregeln für Abschnitt 4 (// ===== 4. Zeichnen mit pdfkit =====; pt; links = SEITE.links, rechts = SEITE.breite − SEITE.rechts; „schreiben“ heißt setzeStil(doc, stil) und dann doc.text(text, x, y, { lineGap: stil.lineGap, …optionen }); „Linie“ heißt eine gerade Linie mit save/restore, Farbe und Breite wie genannt, Vorgabe FARBEN.linie und 0,5 pt; SPALTEN_X[i] = links plus die Breiten der Spalten davor). Jede Seite zeichnet in dieser Reihenfolge: Folgeseitenkopf (ab Seite 2), die Posten der Seite in y-Reihenfolge, Fuß. Seiten ab der zweiten legt doc.addPage() an (ohne Optionen, es gelten die Ränder 0 des Dokuments).

Baustein	Zeichnen
briefkopf (y = Oberkante)	Logo assets.logo 34 pt breit bei (links, y). Wortmarke „WEBklar“ (festes Wort) SemiBold 20 pt, Tinte, characterSpacing: -0.4, lineBreak: false, bei (links + 43, y + 6). Absenderblock rechtsbündig in 190 pt Breite, rechter Rand = rechts: erste Zeile von absender.zeilen SemiBold 8,5 pt Tinte bei y, die übrigen mit \n verbunden in STIL.klein bei y + 13. Rücksendezeile absender.rueckzeile in STIL.klein mit 7 pt, underline: true, lineBreak: false bei (links, y + MASSE.rueckY). Anschrift empfaenger.join('\n') in STIL.adresse bei (links, y + MASSE.adresseY), Breite MASSE.adresseBreite. Angaben masse.infoZeilen: Zeile i bei yi = y + MASSE.adresseY + i × MASSE.infoZeile: Beschriftung STIL.klein bei (MASSE.infoX, yi + 1), Breite 90, lineBreak: false; Wert STIL.text mit schrift: 'semibold', rechtsbündig in [MASSE.infoX + 92, rechts] bei yi. Titel daten.titel in STIL.titel bei (links, y + masse.titelY); Projektzeile <beschriftung.projekt>: <projekt> in STIL.projekt bei (links, y + masse.projektY), beide Breite INHALT_BREITE.
ueberschrift	Text bei (links, y), Breite INHALT_BREITE, Stil STIL.titel wenn stil === 'titel', sonst STIL.ueberschrift.
absatz	STIL[atom.stil], bei (links, y), Breite INHALT_BREITE. Mit kasten: vorher ein abgerundetes Rechteck (Radius 4, Linie 0,5 pt, Füllung FARBEN.flaeche, Rand FARBEN.linie) über (links, y, INHALT_BREITE, atom.hoehe); der Text steht dann bei (links + MASSE.kastenRand, y + MASSE.kastenRand) in INHALT_BREITE − 2 × MASSE.kastenRand.
tabellenkopf	Fläche FARBEN.flaeche über (links, y, INHALT_BREITE, atom.hoehe); atom.spalten[i] in STIL.tabellenkopf bei y + 7, lineBreak: false: Spalte 0 bei SPALTEN_X[0] (Breite SPALTEN[0] − ZELLEN_RAND), Spalten ab 1 bei SPALTEN_X[i] + ZELLEN_RAND (Breite SPALTEN[i] − 2 × ZELLEN_RAND), Spalten 2 bis 4 rechtsbündig; unten Linie FARBEN.linieDunkel, 0,75 pt.
zeile	oben = y + ZELLEN_RAND, alles in STIL.text: zelle.nr bei (SPALTEN_X[0], oben), Breite SPALTEN[0] − ZELLEN_RAND; beschreibung bei (SPALTEN_X[1] + ZELLEN_RAND, oben), Breite SPALTEN[1] − 2 × ZELLEN_RAND; menge, einzelpreis, summe bei SPALTEN_X[2..4], Breite SPALTEN[i] − ZELLEN_RAND, rechtsbündig; unten Linie bei y + atom.hoehe.
summe	Linie FARBEN.tinte, 0,75 pt bei y; label rechtsbündig in [links, SPALTEN_X[4] − ZELLEN_RAND] und betrag rechtsbündig in Spalte 4 (Breite SPALTEN[4] − ZELLEN_RAND), beide STIL.summe bei y + 9, lineBreak: false.
Folgeseitenkopf (bei y = SEITE.oben)	Logo 16 pt breit bei (links, y); „WEBklar“ SemiBold 11 pt, characterSpacing: -0.2, bei (links + 22, y + 2); <titel> <nummer> in STIL.klein, rechtsbündig in 250 pt Breite bis rechts, bei y + 4; Linie bei y + 24.
Fuß (bei y = SEITE.hoehe − MASSE.fussHoehe)	Linie über die Inhaltsbreite bei y. Spalte „Bankverbindung“ (nur wenn fuss.bank nicht leer) bei links, Breite 175, Spalte „Kontakt“ bei links + 190, Breite 225: Beschriftung STIL.fussLabel bei y + 8 (lineBreak: false), Zeilen mit \n in STIL.fuss bei y + 19 mit height: 46 und ellipsis: true. „Seite i von n“ (<seite> <i> <von> <n> aus beschriftung) in STIL.fussLabel, rechtsbündig in 70 pt Breite bis rechts, bei y + 8, lineBreak: false.

• Step 1: Failing Tests schreiben

test/auftraegePdf.test.js (Task 10 hängt zwei Tests an):

import { test } from 'node:test'
import assert from 'node:assert/strict'
import { useTestEnv } from './support/testEnv.js'
import { alleTexte, beispielAuftrag, beispielSettings, leseSeiten, seitenZahl } from './auftraegePdfHilfe.js'

useTestEnv({ appwriteUrl: 'http://127.0.0.1:1', stripeUrl: 'http://127.0.0.1:1' })
const { auftragPdfDaten, erzeugeAuftragPdf, bereinigeTexte } = await import('../server/services/auftraege/pdf.js')
const { AB_TEXTE, WIDERRUFSBELEHRUNG_PROJEKT, WIDERRUFSFORMULAR } = await import('../server/services/auftraege/texte.js')
const { aufwandText } = await import('../server/services/auftraege/auftragSicht.js')
const { AuftragError } = await import('../server/services/auftraege/fehler.js')
const { euroDe } = await import('../server/services/finance/format.js')

const JETZT = new Date('2026-10-06T10:00:00.000Z')
const cp = (...codes) => String.fromCodePoint(...codes)
const FRUEHBEGINN_SATZ = 'Ohne Ihr ausdrückliches Verlangen beginnen wir erst nach Ablauf der Widerrufsfrist.' // V7: AB_TEXTE.termine bei Privatpersonen
const optionen = (extra = {}) => ({ settings: beispielSettings, jetzt: JETZT, ...extra })
const ohneLeerraum = (text) => text.replace(/\s+/g, '')
const gesamtText = (pdf) => leseSeiten(pdf).flat().join('\n')
const privat = { kunde: { ...beispielAuftrag().kunde, firma: '', kundenart: 'privat' } }
const aufwand = { art: 'aufwand', positionen: [], summeCents: null, stundensatzCents: 10000, schaetzungMinuten: 600, zahlungsplan: { art: 'monatlich', prozent: null, text: '' } }

/** Alles, was in den Daten steht und nicht nur Beschriftung oder Schlüssel ist, muss im PDF-Text vorkommen. */
function pruefeAlleTexteImPdf(pdf, auftrag, extra = {}) {
  const daten = bereinigeTexte(auftragPdfDaten(auftrag, optionen(extra)))
  const imPdf = ohneLeerraum(gesamtText(pdf))
  const erwartet = alleTexte({ ...daten, beschriftung: null })
  assert.ok(erwartet.length > 20)
  for (const text of erwartet) assert.ok(imPdf.includes(ohneLeerraum(text)), `fehlt im PDF: ${text.slice(0, 70)}`)
}

test('Festpreis-AB: gültiges A4-PDF, jede Angabe aus den Daten steht im Text', async () => {
  const auftrag = beispielAuftrag()
  const pdf = await erzeugeAuftragPdf(auftrag, optionen())
  assert.ok(Buffer.isBuffer(pdf))
  assert.equal(pdf.subarray(0, 5).toString('latin1'), '%PDF-')
  assert.equal(pdf.subarray(-6).toString('latin1'), '%%EOF\n')
  assert.match(pdf.toString('latin1'), /\/MediaBox \[0 0 595\.28 841\.89\]/)
  const n = seitenZahl(pdf)
  assert.ok(n >= 1)
  assert.equal(leseSeiten(pdf).length, n)
  pruefeAlleTexteImPdf(pdf, auftrag)
  const text = gesamtText(pdf)
  for (const erwartet of ['AB-2026-0007', '06.10.2026', 'K-1042', 'Steuernummer 12/345/67890', euroDe(60000), euroDe(80000), `Seite 1 von ${n}`]) {
    assert.ok(text.includes(erwartet), erwartet)
  }
  assert.equal(text.includes('ENTWURF'), false)
  assert.equal(text.includes('\u{FFFD}'), false)
})

test('Aufwand-AB: Aufwandsregel statt Tabelle', async () => {
  const auftrag = beispielAuftrag(aufwand)
  const pdf = await erzeugeAuftragPdf(auftrag, optionen())
  pruefeAlleTexteImPdf(pdf, auftrag)
  const text = gesamtText(pdf)
  assert.ok(ohneLeerraum(text).includes(ohneLeerraum(aufwandText(auftrag))))
  assert.equal(text.includes('Einzelpreis'), false)
  assert.equal(text.includes('Gesamtpreis'), false)
})

test('Privatperson: Widerrufsbelehrung und Muster-Widerrufsformular auf eigenen Seiten nach der AB', async () => {
  const auftrag = beispielAuftrag(privat)
  const pdf = await erzeugeAuftragPdf(auftrag, optionen())
  const seiten = leseSeiten(pdf)
  const texte = seiten.map((zeilen) => zeilen.join('\n'))
  const index = seiten.findIndex((zeilen) => zeilen.includes(WIDERRUFSBELEHRUNG_PROJEKT.titel))
  assert.ok(index >= 1, 'die Belehrung steht nicht auf Seite 1')
  assert.equal(seiten[index][2], WIDERRUFSBELEHRUNG_PROJEKT.titel, 'sie beginnt oben, direkt unter dem Seitenkopf (WEBklar, Titel und Nummer)')
  assert.ok(texte.slice(index).join('\n').includes(WIDERRUFSFORMULAR.titel))
  assert.ok(ohneLeerraum(texte.join('')).includes(ohneLeerraum(FRUEHBEGINN_SATZ)), 'Satz zum Beginn nach Ablauf der Widerrufsfrist')
  pruefeAlleTexteImPdf(pdf, auftrag)
  texte.forEach((text, i) => assert.ok(text.includes(`Seite ${i + 1} von ${texte.length}`)))
  const unternehmen = gesamtText(await erzeugeAuftragPdf(beispielAuftrag(), optionen()))
  assert.equal(unternehmen.includes(WIDERRUFSFORMULAR.titel), false)
  assert.equal(ohneLeerraum(unternehmen).includes(ohneLeerraum(FRUEHBEGINN_SATZ)), false, 'bei Unternehmen steht der Satz nicht im PDF')
})

test('Umlaute, ß, €, Minuszeichen, Gedankenstrich und Anführungszeichen kommen lesbar im PDF an', async () => {
  const name = `Jörg Müßig${cp(0x2212)}Åström`
  const titel = `Übergabe „Größe“ ${cp(0x2013)} 3${cp(0xa0)}€ ${cp(0x2212)}5${cp(0xa0)}€`
  const auftrag = beispielAuftrag({ titel, kunde: { ...beispielAuftrag().kunde, name, firma: '' } })
  const pdf = await erzeugeAuftragPdf(auftrag, optionen())
  const text = gesamtText(pdf)
  assert.ok(text.includes(name), name)
  assert.ok(ohneLeerraum(text).includes(ohneLeerraum(titel)), titel)
  assert.equal(text.includes('\u{FFFD}'), false)
})

test('Zeichen ohne Glyph werden ersetzt statt als Kästchen gedruckt', async () => {
  const auftrag = beispielAuftrag({ kunde: { ...beispielAuftrag().kunde, firma: '', name: `${cp(0x411, 0x43e, 0x440)} Łukasz`, strasse: `Hauptstraße${cp(0x202f)}12` } })
  const text = gesamtText(await erzeugeAuftragPdf(auftrag, optionen()))
  assert.ok(text.includes('??? Łukasz'))
  assert.ok(text.includes('Hauptstraße 12'))
  assert.equal(text.includes('\u{FFFD}'), false)
})

test('20 Positionen mit 200 Zeichen ohne Leerzeichen: mehrere Seiten, Tabellenkopf auf jeder Seite mit Positionen, nichts geht verloren', async () => {
  const baustein = 'ÄÖÜäöü߀' + cp(0x2212)
  const positionen = Array.from({ length: 20 }, (_, i) => ({ beschreibung: `P${i + 1}${baustein.repeat(30)}`.slice(0, 200), menge: i + 1, einzelpreisCents: 1000 + i }))
  const summeCents = positionen.reduce((s, p) => s + p.menge * p.einzelpreisCents, 0)
  const auftrag = beispielAuftrag({ positionen, summeCents, zahlungsplan: { art: 'nach_abnahme', prozent: null, text: '' } })
  const pdf = await erzeugeAuftragPdf(auftrag, optionen())
  const n = seitenZahl(pdf)
  const seiten = leseSeiten(pdf).map((zeilen) => zeilen.join('\n'))
  assert.ok(n >= 2, `Seiten: ${n}`)
  assert.equal(seiten.length, n)
  const alles = ohneLeerraum(seiten.join('\n'))
  for (const p of positionen) assert.ok(alles.includes(ohneLeerraum(p.beschreibung)), p.beschreibung.slice(0, 12))
  assert.ok(alles.includes(ohneLeerraum(euroDe(summeCents))), 'Gesamtpreis')
  seiten.forEach((text, i) => {
    if (/P\d+/.test(text)) assert.ok(text.includes('Beschreibung') && text.includes('Einzelpreis'), `Seite ${i + 1} ohne Tabellenkopf`)
    assert.ok(text.includes(`Seite ${i + 1} von ${n}`))
    assert.equal(text.includes('\u{FFFD}'), false)
  })
  assert.ok(seiten.find((text) => text.includes('P20')).includes('Gesamtpreis'), 'Summe steht auf der Seite der letzten Position')
})

test('mehrere PDFs gleichzeitig: Schriften sind geteilt, nichts vermischt sich', async () => {
  const nummern = [1, 2, 3, 4, 5].map((i) => `AB-2026-000${i}`)
  const pdfs = await Promise.all(nummern.map((nummer) => erzeugeAuftragPdf(beispielAuftrag({ nummer }), optionen())))
  pdfs.forEach((pdf, i) => {
    const text = gesamtText(pdf)
    assert.ok(text.includes(nummern[i]))
    assert.equal(nummern.filter((n) => text.includes(n)).length, 1)
  })
})

test('unvollständige AB: AuftragError 409 statt halbem PDF', async () => {
  await assert.rejects(erzeugeAuftragPdf(beispielAuftrag({ titel: '' }), optionen()), (e) => e instanceof AuftragError && e.status === 409)
  await assert.rejects(erzeugeAuftragPdf(beispielAuftrag({ kunde: null }), optionen({ vorschau: true })), (e) => e instanceof AuftragError && e.status === 409)
})

• Step 2: Lauf, erwartet FAIL

Run: cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && timeout 900 nice -n 10 node --max-old-space-size=1024 --test test/auftraegePdf.test.js Erwartet: alle acht Tests scheitern („erzeugeAuftragPdf is not a function“).

• Step 3: Abschnitte „Zeichnen“ und „Ablauf“ in pdf.js schreiben

Abschnitt 4 nach den Zeichenregeln (Reihenfolge und Maße wie in der Tabelle), Abschnitt 5 (// ===== 5. Ablauf =====) wie im Block oben. Hinweise zu pdfkit 0.20:

• doc.registerFont(name, buffer) nimmt den Buffer aus ladeSchriften(); pdfkit parst ihn je Dokument (rund 40 KB, vernachlässigbar), gelesen wird er nur einmal je Prozess.

• Wörter, die breiter als die Spalte sind (200 Zeichen ohne Leerzeichen), bricht pdfkits Zeilenumbruch zeichenweise um; das braucht keinen Sonderfall, heightOfString misst es richtig.

• doc.text bricht \n in Absätzen selbst; Texte mit Zeilenumbruch (Anschrift, Fußzeilen, Gruß) brauchen nur einen Aufruf.

• Das Dokument ist ein Readable: data-Ereignisse einsammeln, end abwarten, erst nach dem Zeichnen doc.end(). Scheitert das Zeichnen, doc.destroy() und den Fehler weiterwerfen.

• doc.image(assets.logo, x, y, { width }) nimmt den PNG-Buffer (RGBA mit Transparenz); es gibt keinen Bilder-Cache je Prozess, das Logo hat 5 KB.

• info.CreationDate fest setzen (gesendetAm bzw. jetzt), damit das PDF zu seinem Inhalt passt und nicht zur Uhrzeit des Zeichnens.

• Step 4: Lauf, erwartet PASS

Run: derselbe wie in Step 2. Erwartet: alle acht Tests bestehen.

• Step 5: Commit

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4
git add server/services/auftraege/pdf.js test/auftraegePdf.test.js
git commit -m "AB-PDF: erzeugeAuftragPdf zeichnet Briefkopf, Tabelle über mehrere Seiten, Belehrung und Fuß mit pdfkit

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

---

Task 10: Vorschau-Kennzeichnung und ersetzte AB

Files:

• Modify: server/services/auftraege/pdf.js (Abschnitte 4 und 5)
• Test: test/auftraegePdf.test.js, test/auftraegePdfErsetzt.test.js

Interfaces:

• Consumes: erzeugeAuftragPdf (Task 9); L0 getAuftrag(id) → Auftrag|null aus auftragStore.js (liest fehlende Felder tolerant, Übersicht V4 und L0-Plan); startAppwriteMock und schemaKeys('auftraege') aus test/support.
• Produces: erzeugeAuftragPdf(auftrag, { settings, vorschau = false, jetzt = new Date(), ersetzt } = {}) mit dem Schlüssel ersetzt (seit der Planrunde in V4): { nummer, datum /* 'YYYY-MM-DD' */ } (diese AB wird ersetzt), null (kein Hinweis, kein Lesen) oder weggelassen (hat auftrag.ersetztId einen Wert, liest die Funktion die alte AB über getAuftrag und nimmt nummer und den Berliner Tag von gesendetAm). Findet sie die alte AB nicht (oder ohne Nummer oder Sendedatum), wirft sie AuftragError(409, 'Die ersetzte Auftragsbestätigung wurde nicht gefunden.'): ein Hinweis, der sich auf eine unbekannte AB bezieht, darf nicht still entfallen. Hintergrund: Vertragsfrage 1 (entschieden).

Vorschau-Kennzeichnung (Abschnitt 4, vor allem anderen auf jeder Seite, wenn daten.vorschau): Wasserzeichen beschriftung.entwurf („ENTWURF“) in SemiBold 110 pt, Farbe FARBEN.entwurf, Deckkraft 0,07 (fillOpacity), um −35° um die Seitenmitte gedreht (rotate(-35, { origin })), um die Seitenmitte zentriert (x = mitteX − widthOfString/2, y = mitteY − 110 × 1,2 / 2), lineBreak: false, in save()/restore(); danach der Kopfvermerk beschriftung.entwurfHinweis in SemiBold 8 pt FARBEN.entwurf, mittig in INHALT_BREITE bei (links, 22), lineBreak: false. Die Daten (nummer: 'Entwurf', heutiges Datum) sind schon aus Task 4/5 da.

Änderung in pdf.js (der Rest von erzeugeAuftragPdf bleibt):

async function ladeErsetzte(id) {
  const { getAuftrag } = await import('./auftragStore.js')
  const alt = await getAuftrag(id)
  if (!alt?.nummer || !alt.gesendetAm) throw new AuftragError(409, 'Die ersetzte Auftragsbestätigung wurde nicht gefunden.')
  return { nummer: alt.nummer, datum: berlinDate(new Date(alt.gesendetAm)) }
}

/** Das AB-PDF (A4) als Buffer. */
export async function erzeugeAuftragPdf(auftrag, { settings, vorschau = false, jetzt = new Date(), ersetzt } = {}) {
  const alt = ersetzt !== undefined ? ersetzt : auftrag.ersetztId ? await ladeErsetzte(auftrag.ersetztId) : null
  const daten = bereinigeTexte(auftragPdfDaten(auftrag, { settings, vorschau, jetzt, ersetzt: alt }))
  // … der Rest wie in Task 9: Schriften laden, Dokument anlegen, messen, paginieren, zeichnen, beenden

• Step 1: Failing Tests schreiben

An test/auftraegePdf.test.js anhängen:

test('Vorschau: ENTWURF und Hinweis auf jeder Seite, Nummer „Entwurf“', async () => {
  const pdf = await erzeugeAuftragPdf(beispielAuftrag({ nummer: '', gesendetAm: null }), optionen({ vorschau: true }))
  const seiten = leseSeiten(pdf)
  assert.ok(seiten.length >= 1)
  for (const zeilen of seiten) {
    const text = zeilen.join('\n')
    assert.ok(text.includes('ENTWURF'))
    assert.ok(text.includes('Entwurf – Vorschau, noch keine gültige Auftragsbestätigung'))
  }
  assert.ok(gesamtText(pdf).includes('Entwurf'))
})

test('ersetzte AB: Hinweis mit Nummer und Datum der alten AB im PDF', async () => {
  const pdf = await erzeugeAuftragPdf(beispielAuftrag(), optionen({ ersetzt: { nummer: 'AB-2026-0003', datum: '2026-10-01' } }))
  assert.ok(ohneLeerraum(gesamtText(pdf)).includes(ohneLeerraum(AB_TEXTE.ersetzt({ nummer: 'AB-2026-0003', datum: '01.10.2026' }))))
})

Neue Datei test/auftraegePdfErsetzt.test.js (der Appwrite-Nachbau mit dem Schema aus L0 liefert die alte AB; die Umgebung steht vor dem ersten Import von config.js):

import { test, after } from 'node:test'
import assert from 'node:assert/strict'
import { startAppwriteMock } from './support/appwriteMock.js'
import { schemaKeys } from './support/schema.js'
import { useTestEnv } from './support/testEnv.js'
import { beispielAuftrag, beispielSettings, leseSeiten } from './auftraegePdfHilfe.js'

// Die alte AB liegt im Appwrite-Nachbau (Schema aus L0); erzeugeAuftragPdf liest sie über getAuftrag aus auftragStore.js
const aw = await startAppwriteMock({ schema: { auftraege: schemaKeys('auftraege') } })
after(() => aw.close())
useTestEnv({ appwriteUrl: aw.url, stripeUrl: 'http://127.0.0.1:1' })
const { erzeugeAuftragPdf } = await import('../server/services/auftraege/pdf.js')
const { AB_TEXTE } = await import('../server/services/auftraege/texte.js')
const { AuftragError } = await import('../server/services/auftraege/fehler.js')

const optionen = { settings: beispielSettings, jetzt: new Date('2026-10-06T10:00:00.000Z') }
const ohneLeerraum = (text) => text.replace(/\s+/g, '')
const text = (pdf) => ohneLeerraum(leseSeiten(pdf).flat().join(''))
const hinweis = ohneLeerraum(AB_TEXTE.ersetzt({ nummer: 'AB-2026-0003', datum: '01.10.2026' }))

aw.seed('auftraege', { $id: 'alt1', kundenId: 'k1', status: 'versendet', nummer: 'AB-2026-0003', gesendetAm: '2026-10-01T09:00:00.000+00:00' })

test('ersetztId ohne Option: die alte AB wird gelesen, ihre Nummer und ihr Berliner Datum stehen im PDF', async () => {
  const pdf = await erzeugeAuftragPdf(beispielAuftrag({ ersetztId: 'alt1' }), optionen)
  assert.ok(text(pdf).includes(hinweis))
})

test('ersetztId verweist auf eine unbekannte AB: AuftragError 409 statt PDF ohne den Hinweis', async () => {
  await assert.rejects(erzeugeAuftragPdf(beispielAuftrag({ ersetztId: 'gibtsnicht' }), optionen), (e) => e instanceof AuftragError && e.status === 409)
})

test('ersetzt: null unterdrückt Hinweis und Lesen, auch bei gesetztem ersetztId', async () => {
  const pdf = await erzeugeAuftragPdf(beispielAuftrag({ ersetztId: 'gibtsnicht' }), { ...optionen, ersetzt: null })
  assert.equal(text(pdf).includes(hinweis), false)
})

• Step 2: Lauf, erwartet FAIL

Run: cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && timeout 900 nice -n 10 node --max-old-space-size=1024 --test test/auftraegePdf.test.js test/auftraegePdfErsetzt.test.js Erwartet: Vorschau …, ersetzte AB … und die ersten beiden Tests in auftraegePdfErsetzt.test.js scheitern (der dritte besteht schon, er sichert nur, dass null nichts liest); die acht Tests aus Task 9 bestehen.

• Step 3: Wasserzeichen und ersetzt umsetzen

zeichneAuftrag ruft vor allem anderen auf jeder Seite die Vorschau-Kennzeichnung auf, wenn daten.vorschau. erzeugeAuftragPdf löst ersetzt wie im Block oben auf; ladeErsetzte importiert ./auftragStore.js dynamisch (so bleibt pdf.js ohne Appwrite ladbar, und L3 braucht für Tests nur Attrappen).

• Step 4: Lauf, erwartet PASS

Run: derselbe wie in Step 2. Erwartet: zehn Tests in auftraegePdf.test.js und drei in auftraegePdfErsetzt.test.js bestehen.

• Step 5: Commit

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4
git add server/services/auftraege/pdf.js test/auftraegePdf.test.js test/auftraegePdfErsetzt.test.js
git commit -m "AB-PDF: Entwurfs-Kennzeichnung für die Vorschau und Hinweis auf die ersetzte AB

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

---

Task 11: Selbstprüfung

Files:

• keine neuen; nur Prüfen, Korrigieren (eigene Dateien) und ein Commit, falls etwas zu korrigieren war.

Interfaces:

• Consumes: alle Ergebnisse der Tasks 2 bis 10.

• Produces: grüne eigene Tests, abgehakte Vertragsliste, Beispiel-PDFs für die Kontrolle in Strang Z.

• Step 1: Eigene Tests (Host, Node 24)

Vorher free -m (unter 1500 MB „available“ warten).

Run: cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && timeout 900 nice -n 10 node --max-old-space-size=1024 --test --test-concurrency=1 test/auftraegePdf*.test.js Erwartet: # fail 0; 48 Tests in sechs Dateien (8 + 14 + 12 + 1 + 10 + 3).

• Step 2: Dieselben Tests unter Node 20 (Version des Containers)

free -m | head -2
flock /tmp/claude-0/-root/dc97e1da-8b3d-40c0-9943-f8c37f910877/scratchpad/auftraege-schwer.lock \
  timeout 600 docker run --rm --network none -m 900m \
  -v /home/webklar/apps/kundenbereich.webklar.com:/w:ro -w /w/dev-auftraege-l4 \
  node:20-alpine node --max-old-space-size=512 --test --test-concurrency=1 test/auftraegePdf*.test.js 2>&1 | tail -15

Erwartet: # fail 0. (Der Symlink node_modules zeigt relativ auf ../dev-auftraege/node_modules und löst im Container über den eingehängten Elternordner auf.)

• Step 3: Vertragsliste abhaken

• pdf.js exportiert auftragPdfDaten(auftrag, { settings, vorschau = false }) (reine Funktion) und erzeugeAuftragPdf(auftrag, { settings, vorschau = false }) → Promise<Buffer> (V4); jetzt und ersetzt stehen seit der Planrunde in V4.

• settings = { steuernummer, bankDetailsText }: Steuernummer im Briefkopf (Zeile entfällt, wenn leer), Bankverbindung im Fuß.

• Schrift: nur Figtree Regular und SemiBold, statisch, in server/assets/fonts/ mit Figtree-OFL.txt und QUELLE.txt; Logo public/webklar-logo.png; beides einmal je Prozess geladen.

• Inhalt laut Spec Abschnitt 2 „Inhalt des PDFs“: Briefkopf (Logo, WEBklar GbR, Anschrift, Kontakt, Steuernummer), Empfänger, Titel/Nummer/Datum/Projekt/Kundennummer, Einleitung, Positionen mit Menge/Einzelpreis/Summe und Gesamtpreis oder Aufwandsregel, § 19-Hinweis, Zahlungsplan mit Beträgen, Termine, Mitwirkung und Abnahme, AGB-Satz mit Fassung, ersetzt-Hinweis, bei Privatperson Widerrufsbelehrung und Muster-Widerrufsformular auf neuer Seite, Fuß mit Bankverbindung, Kontakt und „Seite X von Y“, bei Vorschau Wasserzeichen und Kopfvermerk „Entwurf“.

• Namen aus V7 verwendet: ABSENDER, AB_TEXTE.{titel, einleitung, kleinunternehmer, termine, mitwirkung, agb, ersetzt, gruss}, WIDERRUFSBELEHRUNG_PROJEKT, WIDERRUFSFORMULAR; aus V3: zahlungsplanText, aufwandText; kein eigener Wortlaut außer den Beschriftungen in PDF_BESCHRIFTUNG.

• AB_TEXTE.termine({ start, fertig, privat }) bekommt privat = (kunde.kundenart === 'privat'): bei Privatpersonen steht der Abschnitt „Termine“ mit dem Satz „Ohne Ihr ausdrückliches Verlangen beginnen wir erst nach Ablauf der Widerrufsfrist.“ im PDF (auch ohne Daten), bei Unternehmen nicht (Tests in Task 5 und Task 9).

• Global Constraints der Übersicht: Beträge über euroDe, Datum TT.MM.JJJJ nach Berliner Tag, kein Chrome, Tests nur mit Nachbauten, keine IP-Adressen, Commits klein mit Schlusszeile, kein Push, kein git add -A.

• Review Focus 1 bis 5 durch grüne Tests belegt (Task 3, 4, 5, 6, 7, 9).

• Die Vertragsfragen am Ende dieser Datei tragen den Entscheidungsstand der Übersicht (Abschnitt „Nachträge nach der Planrunde“); nichts davon ist noch offen.

• Step 4: Nur eigene Dateien geändert

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4
git diff --name-only feature/auftraege...HEAD | command grep -a -v -E '^(server/services/auftraege/pdf\.js|server/assets/fonts/(Figtree-Regular\.ttf|Figtree-SemiBold\.ttf|Figtree-OFL\.txt|QUELLE\.txt)|test/auftraegePdf[A-Za-z]*\.(test\.)?js)$'

Erwartet: keine Ausgabe.

• Step 5: Beispiel-PDFs schreiben und ansehen

Skript /tmp/claude-0/-root/dc97e1da-8b3d-40c0-9943-f8c37f910877/scratchpad/auftraege-pdf/erzeuge.mjs (nur Scratchpad, nicht ins Repo):

import { mkdirSync, writeFileSync } from 'node:fs'

const WT = '/home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4'
const OUT = new URL('./', import.meta.url)
const { beispielAuftrag, beispielSettings } = await import(`${WT}/test/auftraegePdfHilfe.js`)
const { erzeugeAuftragPdf } = await import(`${WT}/server/services/auftraege/pdf.js`)

const kunde = beispielAuftrag().kunde
const positionen = Array.from({ length: 20 }, (_, i) => ({
  beschreibung: `Position ${i + 1}: ${i % 3 === 0 ? 'X'.repeat(190) : 'Ausführliche Beschreibung der Leistung mit Umlauten äöüß und Zeichen wie € – „Test“. '.repeat(2)}`,
  menge: i + 1,
  einzelpreisCents: 1000 + i,
}))
const aufwand = { art: 'aufwand', positionen: [], summeCents: null, stundensatzCents: 10000, schaetzungMinuten: 600, zahlungsplan: { art: 'monatlich', prozent: null, text: '' } }
const faelle = {
  festpreis: [beispielAuftrag(), {}],
  'festpreis-20-positionen': [beispielAuftrag({ positionen, summeCents: positionen.reduce((s, p) => s + p.menge * p.einzelpreisCents, 0), zahlungsplan: { art: 'nach_abnahme', prozent: null, text: '' } }), {}],
  aufwand: [beispielAuftrag(aufwand), {}],
  privat: [beispielAuftrag({ kunde: { ...kunde, firma: '', name: 'Jörg Müßig-Åström', kundenart: 'privat' } }), {}],
  vorschau: [beispielAuftrag({ nummer: '', gesendetAm: null }), { vorschau: true }],
}
mkdirSync(OUT, { recursive: true })
for (const [name, [auftrag, optionen]] of Object.entries(faelle)) {
  const start = Date.now()
  const pdf = await erzeugeAuftragPdf(auftrag, { settings: beispielSettings, ersetzt: null, ...optionen })
  writeFileSync(new URL(`${name}.pdf`, OUT), pdf)
  console.log(name, pdf.length, 'Bytes', Date.now() - start, 'ms')
}
console.log('Speicher: Heap', Math.round(process.memoryUsage().heapUsed / 1e6), 'MB, RSS', Math.round(process.memoryUsage().rss / 1e6), 'MB')

S=/tmp/claude-0/-root/dc97e1da-8b3d-40c0-9943-f8c37f910877/scratchpad/auftraege-pdf
mkdir -p $S && cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4 && node --max-old-space-size=256 $S/erzeuge.mjs
free -m | head -2
flock /tmp/claude-0/-root/dc97e1da-8b3d-40c0-9943-f8c37f910877/scratchpad/auftraege-schwer.lock \
  timeout 300 docker run --rm --network none -m 700m --user 0:0 -v $S:/pdf --entrypoint sh \
  ghcr.io/paperless-ngx/paperless-ngx:2.20.15 -c 'cd /pdf && for f in *.pdf; do b=${f%.pdf}; pdfinfo "$f" | grep -E "Pages|Page size"; pdftoppm -png -r 70 "$f" "$b"; pdftotext -layout "$f" "$b.txt"; done; pdffonts festpreis.pdf'
ls $S

Die Ausgabe des Skripts zeigt je PDF die Dauer und am Ende den Speicher: erwartet weniger als 1000 ms je Datei und Heap unter 100 MB (Referenzstand: 45 bis 115 ms, 27 MB); die Erzeugung darf den Server nicht belasten. Das Paperless-Image enthält pdftoppm, pdftotext, pdfinfo und pdffonts (Poppler); fehlt es, bleiben es die PDFs (Hinweis in der Übergabe). pdffonts darf nur Figtree-Regular und Figtree-SemiBold zeigen (eingebettet, Teilmenge, Unicode-Tabelle: yes yes yes), kein Helvetica. Die PNGs (festpreis-1.png, festpreis-20-positionen-1.png bis -4.png, aufwand-1.png, privat-1.png, -2.png, vorschau-1.png) mit dem Lesewerkzeug ansehen und prüfen: Briefkopf mit Logo, Absender und Steuernummer rechts; Anschrift unter der Rücksendezeile; Tabelle mit Kopf auf jeder Folgeseite; Summe bei der letzten Position; Fuß mit „Seite i von n“; Privatperson: Belehrung beginnt oben auf einer neuen Seite; Vorschau: diagonales „ENTWURF“ und roter Kopfvermerk; kein Text über den Rand, keine leeren Kästchen. Fällt etwas auf: in den eigenen Dateien korrigieren (Test dazu) und committen.

• Step 6: Abschluss

cd /home/webklar/apps/kundenbereich.webklar.com/dev-auftraege-l4
git status --short
git log --oneline feature/auftraege..HEAD

Erwartet: git status zeigt nichts (der Symlink node_modules ist über .gitignore ignoriert; steht dort ?? node_modules, fehlt L0s Eintrag: dem Orchestrator melden); git log zeigt die Commits der Tasks 2 bis 10 (und ggf. Korrekturen aus Step 5). Übergabe an Strang Z: Pfad der Beispiel-PDFs (…/scratchpad/auftraege-pdf/), die Vertragsfragen unten, Commit-Stand.

---

Vertragsfragen

Alle Punkte sind in der Planrunde entschieden oder bestätigt; maßgeblich ist die Übersicht (Abschnitt „Nachträge nach der Planrunde“, V4, V5, V7). Dieser Plan ist darauf angepasst. Stand je Punkt:

1. Der „ersetzt“-Hinweis braucht Nummer und Datum der alten AB: entschieden (siehe Übersicht, Nachträge). V4 führt ersetzt = { nummer, datum } als Option von auftragPdfDaten und erzeugeAuftragPdf; ohne sie liest L4 die alte AB über getAuftrag(auftrag.ersetztId). Umsetzung: Task 5 und Task 10.
2. Optionaler Schlüssel jetzt: entschieden (siehe Übersicht, Nachträge), steht in V4. Er bestimmt das Datum der AB, wenn gesendetAm fehlt (Vorschau), und das CreationDate der PDF-Metadaten. L3 übergibt beim Senden nummer, gesendetAm und agbFassung im Objekt, jetzt greift dort nicht. Ist agbFassung leer, gilt AGB_FASSUNG (wie bei agbUrl in V3).
3. Die 409-Klartexte von L4: entschieden (siehe Übersicht, Nachträge). L3 reicht AuftragError aus erzeugeAuftragPdf unverändert durch (andere Fehler werden 500), und V5 nennt für GET …/auftraege/:id/pdf 404 und 409 „Entwurf unvollständig“. L4 wirft die Meldungen wie in Task 4 beschrieben.
4. Parameter der Textfunktionen: entschieden (siehe Übersicht, Nachträge; V7 führt privat in AB_TEXTE.termine): weg ist das deutsche Wort aus AUFTRAG_WEGE, schaetzung ein Stundentext, Beträge sind euroDe-Texte, und AB_TEXTE.termine({ start, fertig, privat }) bekommt privat von L4. Bei Privatpersonen liefert termine immer Text (mit dem Satz „Ohne Ihr ausdrückliches Verlangen beginnen wir erst nach Ablauf der Widerrufsfrist.“), bei Unternehmen null, wenn beide Daten fehlen. Tests: Task 4, Task 5 (Termine: Privatpersonen …) und Task 9 (Privatperson: …).
5. Zeichenvorrat der Texte (L7): keine Entscheidung nötig, bleibt als Hinweis an L7. Es zählen nur Zeichen, die Figtree Regular und SemiBold abdecken (392 Codepunkte: Basic Latin, Latin-1, Latin Extended-A und Teile von B, „ “ ‚ ‘ – — … € − • → u. a.). Nicht enthalten sind unter anderem U+202F und U+2009 (schmale Leerzeichen), Häkchen, Emoji und kyrillische Schrift. Der Wächter-Test in Task 5 schlägt dann an; L7 soll node --test test/auftraegePdfDaten.test.js nach jeder Textänderung laufen lassen. Im PDF selbst ersetzt bereinigeText ein fehlendes Zeichen still (der Wortlaut ist dann nicht wie freigegeben).
6. WIDERRUFSFORMULAR.zeilen: keine Entscheidung nötig, bleibt als Hinweis an L7. L4 druckt jede Zeile als eigenen Absatz unverändert (ein führendes „–“ muss in texte.js stehen), ohne Ausfüllfelder oder Linien.
7. Leere Steuernummer: entschieden (siehe Übersicht, Nachträge). Die Zeile entfällt im PDF (kein Platzhalter); W2 zeigt im AB-Dialog einen Hinweis.
8. fontkit: entschieden (siehe Übersicht, Nachträge). L0 trägt fontkit als direkte Abhängigkeit in package.json ein (Version wie die pdfkit-Abhängigkeit); L4 importiert es direkt. Task 1 prüft den Eintrag.
9. Schrift- und Logo-Pfade der Spec: entschieden (siehe Übersicht, Nachträge). Die Spec nennt jetzt „statische Figtree-Schnitte (OFL) unter server/assets/fonts/, Logo public/webklar-logo.png“; dieser Plan setzt genau das um.
10. Testhilfe und Symlink: entschieden (siehe Übersicht, Nachträge). Testhilfen ohne .test.js gehören dem anlegenden Strang, test/auftraegePdfHilfe.js also L4. L0 trägt node_modules ohne Schrägstrich in .gitignore ein, damit erscheint der Symlink der Lane-Worktrees nicht mehr in git status (Task 1 und Task 11 erwarten eine leere Ausgabe).
11. Schriftquelle und Lizenz: entschieden (siehe Übersicht, Nachträge): statische Figtree-TTFs aus @expo-google-fonts/figtree (OFL) unter server/assets/fonts/. Das Paket ist als „MIT AND OFL-1.1“ lizenziert (MIT für das Paket, OFL für die Schriften); mitgeliefert wird nur der OFL-Text der Schrift (Figtree-OFL.txt). Bei einer neueren Figtree-Fassung ändern sich Prüfsummen und Glyphenmenge; Test und QUELLE.txt dann gemeinsam anpassen.
12. Test-Nachbau: bestätigt durch den L0-Plan, keine Entscheidung nötig: Task 10 braucht schemaKeys('auftraege') (test/support/schema.js) und getAuftrag (auftragStore.js); Task 1 prüft sie.