feat: Stammdaten, Ersteinrichtung, Zweitfaktor und Protokollansicht

Damit ist Etappe 1 fachlich vollstaendig.

Ersteinrichtung in drei Schritten, bewusst ausserhalb des
Anwendungsrahmens: der setzt Benutzer, zweiten Faktor UND eine betreute
Person voraus - beim allerersten Start gibt es nichts davon. Die Aktion
fuer den ersten Zugang sperrt sich selbst, sobald ein Benutzer existiert.

Zweiter Faktor: Das Geheimnis wird zuerst nur abgelegt, ohne
totpAktiviertAm. Erst ein echter Code aus der App schaltet ihn scharf.
Wer sich beim Abtippen vertut oder die falsche App nimmt, wuerde sich
sonst dauerhaft aussperren. Erst danach gibt es die
Wiederherstellungscodes - einmal angezeigt, danach nur noch als Hash.

Betreuungsjahr (src/lib/stammdaten/betreuungsjahr.ts): laeuft ab dem Tag
der Bestellung, nicht ab dem Kalenderjahr. Schrittweise vorwaerts
gerechnet statt ueber eine Differenz, damit Schaltjahre und der
29. Februar von selbst stimmen. Daran haengen Jahresbericht,
Rechnungslegung und die Ausschlussfrist der Aufwandspauschale.

Aendert sich das Bestellungsdatum, werden die Pflichtfristen neu
abgeleitet - ueber einen dynamischen Import, damit die Stammdaten auch
dann speicherbar bleiben, wenn das Fristenmodul fehlt.

Protokollansicht zeigt je Eintrag die geaenderten Felder als alt -> neu.
Die Aenderungen liegen verschluesselt, weil dort Diagnosen und
Kontostaende stehen koennen.

Seed legt bewusst keine echten Personendaten an, nur den ersten Zugang.
Mit SEED_DEMO=true kommt ein vollstaendiger Beispielfall dazu - Erika
Musterfrau, COPD GOLD III, Pflegegrad 3, Heimeinzug Januar 2026,
leerstehendes Haus, zwei Versicherungen, laufender Antrag beim Bezirk
mit acht Nachforderungen. Nur ausserhalb der Produktion.

Docker Compose ohne Reverse Proxy - der ist auf dem Zielserver
vorhanden. Die Datenbank hat keine Portfreigabe und ist nur ueber das
interne Netz erreichbar; die Anwendung horcht auf 127.0.0.1.

Etappe: 1
Phase: Fundament

src/lib/speicher/s3.ts

@@ -0,0 +1,104 @@
+import 'server-only'
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from '@aws-sdk/client-s3'
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
+import { env } from '@/lib/env'
+import { schluesselErfordern, TOKEN_STANDARD_SEKUNDEN } from '@/lib/speicher/schluessel'
+
+/**
+ * Treiber "s3": S3-kompatibler Objektspeicher, betrieben in der EU.
+ *
+ * Voraussetzung fuer den Einsatz ist ein Auftragsverarbeitungsvertrag nach
+ * Art. 28 DSGVO mit dem Anbieter - hier liegen Gesundheits- und
+ * Finanzdaten. Ohne diesen Vertrag bleibt es beim Dateitreiber.
+ *
+ * Ausgeliefert wird nur ueber kurzlebige presigned URLs. Sie tragen
+ * Content-Disposition: attachment und einen festen Content-Type, damit der
+ * Objektspeicher eine hochgeladene Datei niemals als HTML im Browser
+ * rendern kann.
+ */
+
+let klient: S3Client | null = null
+
+function s3(): S3Client {
+  if (klient) return klient
+  const k = env.s3
+  klient = new S3Client({
+    region: k.region,
+    endpoint: k.endpoint,
+    // Viele S3-kompatible Anbieter (MinIO, Hetzner) brauchen Pfad-Stil.
+    forcePathStyle: true,
+    credentials: { accessKeyId: k.accessKeyId, secretAccessKey: k.secretAccessKey },
+  })
+  return klient
+}
+
+function eimer(): string {
+  return env.s3.bucket
+}
+
+export async function schreiben(
+  schluessel: string,
+  inhalt: Buffer,
+  mimeTyp: string,
+): Promise<void> {
+  const geprueft = schluesselErfordern(schluessel)
+  await s3().send(
+    new PutObjectCommand({
+      Bucket: eimer(),
+      Key: geprueft,
+      Body: inhalt,
+      ContentType: mimeTyp,
+      // Auch beim direkten Abruf niemals im Browser darstellen.
+      ContentDisposition: 'attachment',
+      // Serverseitige Verschluesselung, wo der Anbieter sie unterstuetzt.
+      ServerSideEncryption: 'AES256',
+    }),
+  )
+}
+
+export async function lesen(schluessel: string): Promise<Buffer> {
+  const geprueft = schluesselErfordern(schluessel)
+  const antwort = await s3().send(new GetObjectCommand({ Bucket: eimer(), Key: geprueft }))
+  if (!antwort.Body) throw new Error(`Objekt ${geprueft} ist leer.`)
+  const bytes = await antwort.Body.transformToByteArray()
+  return Buffer.from(bytes)
+}
+
+export async function entfernen(schluessel: string): Promise<void> {
+  const geprueft = schluesselErfordern(schluessel)
+  await s3().send(new DeleteObjectCommand({ Bucket: eimer(), Key: geprueft }))
+}
+
+export async function existiert(schluessel: string): Promise<boolean> {
+  const geprueft = schluesselErfordern(schluessel)
+  try {
+    await s3().send(new HeadObjectCommand({ Bucket: eimer(), Key: geprueft }))
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function signierteUrl(
+  schluessel: string,
+  sekunden: number = TOKEN_STANDARD_SEKUNDEN,
+): Promise<string> {
+  const geprueft = schluesselErfordern(schluessel)
+  return getSignedUrl(
+    s3(),
+    new GetObjectCommand({
+      Bucket: eimer(),
+      Key: geprueft,
+      // Die Antwort des Objektspeichers wird hier festgenagelt: Anhang,
+      // niemals HTML, egal was beim Hochladen gemeldet wurde.
+      ResponseContentDisposition: 'attachment',
+    }),
+    { expiresIn: Math.min(Math.max(Math.floor(sekunden), 1), 60 * 60) },
+  )
+}