Phase 4 abgeschlossen: Personalakten, Dokumente, Beteiligte, Verknüpfungen

Die Dokumentebene aus docs/13 ist gebaut, additiv: Document, DocumentSection
und DocumentSectionVersion neben Case, CaseSection und CaseEntry. Ein Dokument
hängt an einer Fallakte, an einer Personalakte oder an nichts, höchstens an
einem - gesichert durch eine CHECK-Bedingung. Es gibt kein DELETE; eine
Zurücknahme lässt einen Grabstein stehen, der auch für den Admin zu ist.

Eine neue Dokumentart ist damit ein Datensatz, kein Deployment. Im Seed stehen
vier: vermerk, vorfallsbericht, sonderarbeitsvertrag (mehrseitiger Vertragstext
mit Platzhaltern und Unterschriftenzeilen) und bussgeld.

Zwei Umbenennungen, beide von Hand migriert, damit die vorhandenen Zeilen und
Zählerstände stehen bleiben:
- CaseTemplate -> DocumentTemplate, plus uses[] und layout
- CaseCounter -> NumberSeries, ein Nummernkreis je Präfix für Aktenzeichen
  und Dokumentnummern

Die Regeln für Abschnitte stehen jetzt einmal in lib/sections/render.ts und
gelten für Fallakten und Dokumente gleichermaßen. Die Frage aus docs/13, ob
CaseSection langfristig in die Dokumentebene wandert, ist damit verneint und
begründet.

Rückverweise auf der Personalakte laufen durch visibleCaseWhere, die Zahl
daneben entsteht aus dem gefilterten Ergebnis. Auch die Rollengruppe
verschwindet mit, sonst verriete "Betroffener" ohne Eintrag die Ermittlung.
Die eigene Personalakte ist keine Ausnahme von der Freigabestufe.

Vier neue Rechte: document.create, .edit, .finalize, .retract. Das letzte
steht bei den zurückgehaltenen, es greift in Geschriebenes ein.

91 Tests im Web-Paket, 15 in der Datenbank, 28 e2e. Größte Route 118 kB
gegen das Budget von 120 kB - die Luft wird knapp.

web/lib/cases/sectionService.ts

@@ -1,97 +1,44 @@
 import { db } from '@/lib/db'
 import { writeAudit } from '@/lib/audit'
 import { canEditCase } from '@/lib/access/caseWrite'
-import { AccessError, loadVisibleCase } from '@/lib/cases/service'
-import { isInputField, type TemplateField } from '@/lib/templates/fields'
+import { loadVisibleCase } from '@/lib/cases/service'
+import { AccessError } from '@/lib/errors'
 import { parseTemplateFields } from '@/lib/templates/schema'
-import { redactForLevel, type Segment } from '@/lib/redaction'
+import {
+  asJson,
+  planSectionSave,
+  renderSections,
+  type RenderedSection,
+} from '@/lib/sections/render'
+import type { TemplateField } from '@/lib/templates/fields'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
-import type { Prisma } from '@afis/db'
 
 /**
  * Abschnitte einer Fallakte: der aktuelle Sachstand, aus der Vorlage erzeugt
  * und je Feld versioniert. Siehe docs/05-akten-und-vorlagen.md.
+ *
+ * Die Regeln stehen in `lib/sections/render.ts`, weil Dokumente dieselben
+ * haben. Hier steht nur, welche Tabelle gelesen und geschrieben wird.
  */
 
-/** Was ein Leser sieht, dessen Stufe für ein Feld nicht reicht. */
-export type Placeholder = { redacted: true; requiredLevel: number }
-
-export type RenderedSection = {
-  fieldKey: string
-  field: TemplateField
-  version: number
-  updatedAt: Date | null
-  updatedById: string | null
-} & (
-  | { visible: true; value: unknown; segments: Segment[] | null }
-  | { visible: false; value: Placeholder }
-)
-
-/**
- * Prisma trennt „Feld nicht setzen" von „JSON null". Ein leerer Abschnitt ist
- * inhaltlich JSON null, nicht das Fehlen des Feldes.
- */
-function asJson(value: unknown): Prisma.InputJsonValue {
-  return (value ?? null) as Prisma.InputJsonValue
-}
+export type { RenderedSection, Placeholder } from '@/lib/sections/render'
+export { ConflictError } from '@/lib/errors'
 
 export function templateFields(raw: unknown): TemplateField[] {
   return parseTemplateFields(raw)
 }
 
-/**
- * Lädt die Abschnitte einer Akte und wendet dabei die Stufe des Lesers an.
- *
- * Felder über seiner Stufe werden **serverseitig** durch einen Platzhalter
- * ersetzt. Der echte Wert verlässt den Server nicht — nie im Client
- * ausblenden. Dasselbe gilt für Schwärzungen im Fliesstext, die als Segmente
- * zurückkommen.
- */
 export async function loadSections(
   p: EffectivePermissions,
   caseId: string,
   templateId: string,
 ): Promise<RenderedSection[]> {
   const [template, rows] = await Promise.all([
-    db.caseTemplate.findUnique({ where: { id: templateId }, select: { fields: true } }),
+    db.documentTemplate.findUnique({ where: { id: templateId }, select: { fields: true } }),
     db.caseSection.findMany({ where: { caseId } }),
   ])
 
-  const fields = templateFields(template?.fields)
-  const byKey = new Map(rows.map((row) => [row.fieldKey, row]))
-
-  return fields.map((field): RenderedSection => {
-    const row = byKey.get(field.key)
-    const required = Math.max(field.minClearance ?? 0, row?.minClearance ?? 0)
-    const common = {
-      fieldKey: field.key,
-      field,
-      version: row?.currentVersion ?? 0,
-      updatedAt: row?.updatedAt ?? null,
-      updatedById: row?.updatedById ?? null,
-    }
-
-    if (!p.isAdmin && required > p.clearanceLevel) {
-      return { ...common, visible: false, value: { redacted: true, requiredLevel: required } }
-    }
-
-    const value = row?.value ?? null
-    const segments =
-      isInputField(field) && field.type === 'longtext' && typeof value === 'string'
-        ? redactForLevel(value, p.clearanceLevel)
-        : null
-
-    return { ...common, visible: true, value, segments }
-  })
-}
-
-export class ConflictError extends Error {
-  constructor(
-    readonly current: { value: unknown; version: number; updatedById: string | null },
-  ) {
-    super('conflict')
-    this.name = 'ConflictError'
-  }
+  return renderSections(templateFields(template?.fields), rows, p)
 }
 
 /**
@@ -99,7 +46,6 @@ export class ConflictError extends Error {
  *
  * Der Client schickt die Version mit, die er geladen hat. Weicht sie ab, gibt
  * es kein stilles Überschreiben, sondern einen Konflikt mit beiden Fassungen.
- * Siehe docs/05-akten-und-vorlagen.md.
  */
 export async function saveSection(
   p: EffectivePermissions,
@@ -118,32 +64,24 @@ export async function saveSection(
   const check = canEditCase(p, target)
   if (!check.ok) throw new AccessError(check.reason)
 
-  const template = await db.caseTemplate.findUnique({
+  const template = await db.documentTemplate.findUnique({
     where: { id: target.templateId },
     select: { fields: true },
   })
   const field = templateFields(template?.fields).find((f) => f.key === input.fieldKey)
-  if (!field || !isInputField(field)) throw new AccessError('field-unknown')
+  if (!field) throw new AccessError('field-unknown')
 
   const existing = await db.caseSection.findUnique({
     where: { caseId_fieldKey: { caseId: target.id, fieldKey: input.fieldKey } },
   })
 
-  const required = Math.max(field.minClearance ?? 0, existing?.minClearance ?? 0)
-  if (!p.isAdmin && required > p.clearanceLevel) throw new AccessError('clearance-too-low')
-
-  const nextClearance = input.minClearance ?? existing?.minClearance ?? field.minClearance ?? 0
-  if (nextClearance > p.clearanceLevel && !p.isAdmin) throw new AccessError('clearance-too-low')
-
-  if ((existing?.currentVersion ?? 0) !== input.baseVersion) {
-    throw new ConflictError({
-      value: existing?.value ?? null,
-      version: existing?.currentVersion ?? 0,
-      updatedById: existing?.updatedById ?? null,
-    })
-  }
-
-  const nextVersion = (existing?.currentVersion ?? 0) + 1
+  const { nextClearance, nextVersion } = planSectionSave({
+    p,
+    field,
+    existing,
+    baseVersion: input.baseVersion,
+    minClearance: input.minClearance,
+  })
 
   await db.$transaction(async (tx) => {
     if (existing) {