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/caseNumber.ts

@@ -1,65 +0,0 @@
-import type { Prisma } from '@afis/db'
-
-/**
- * Aktenzeichen. Das Muster gehört zur Vorlage, nicht ins Programm: die
- * Abteilung führt gewachsene Präfixe wie `AKT-PA-2026-62843` neben dem
- * `AfiS-2026-0042` aus dem Glossar. Siehe docs/13-entscheidungen.md.
- */
-export type NumberPattern = { prefix: string; padding: number }
-
-export const DEFAULT_PATTERN: NumberPattern = { prefix: 'AfiS', padding: 4 }
-
-export function formatCaseNumber(
-  year: number,
-  number: number,
-  pattern: NumberPattern = DEFAULT_PATTERN,
-): string {
-  return `${pattern.prefix}-${year}-${String(number).padStart(pattern.padding, '0')}`
-}
-
-/**
- * Ein Präfix darf Bindestriche enthalten (`AKT-PA`). Zerlegt wird deshalb von
- * hinten: die letzten beiden Abschnitte sind Jahr und laufende Nummer, alles
- * davor ist das Präfix.
- */
-const PATTERN = /^([A-Za-z][A-Za-z0-9-]*)-(\d{4})-(\d+)$/
-
-export function parseCaseNumber(
-  value: string,
-): { prefix: string; year: number; number: number } | null {
-  const match = PATTERN.exec(value.trim())
-  if (!match) return null
-  return { prefix: match[1]!, year: Number(match[2]), number: Number(match[3]) }
-}
-
-/** Erkennt Aktenzeichen im Fliesstext, für die Vorschaukarten im Chat. */
-export const CASE_NUMBER_GLOBAL = /\b[A-Za-z][A-Za-z0-9-]*-\d{4}-\d{3,8}\b/g
-
-/**
- * Vergibt das nächste Aktenzeichen im Nummernkreis dieses Präfixes und Jahres.
- *
- * `INSERT … ON CONFLICT DO UPDATE` sperrt die Zeile für die Dauer der
- * Transaktion. Zwei gleichzeitige Anlagen warten dadurch aufeinander, statt
- * dieselbe Nummer zu ziehen. Läuft in **derselben** Transaktion wie das
- * Anlegen des Falls, siehe docs/04-datenmodell.md.
- */
-export async function nextCaseNumber(
-  tx: Prisma.TransactionClient,
-  pattern: NumberPattern = DEFAULT_PATTERN,
-  year = new Date().getFullYear(),
-): Promise<string> {
-  const rows = await tx.$queryRaw<{ lastNumber: number }[]>`
-    INSERT INTO "CaseCounter" ("prefix", "year", "lastNumber")
-    VALUES (${pattern.prefix}, ${year}, 1)
-    ON CONFLICT ("prefix", "year") DO UPDATE
-      SET "lastNumber" = "CaseCounter"."lastNumber" + 1
-    RETURNING "lastNumber"
-  `
-
-  const lastNumber = rows[0]?.lastNumber
-  if (lastNumber === undefined) {
-    throw new Error('Aktenzeichen konnte nicht vergeben werden')
-  }
-
-  return formatCaseNumber(year, lastNumber, pattern)
-}

web/lib/cases/links.ts

@@ -0,0 +1,128 @@
+import { db } from '@/lib/db'
+import { writeAudit } from '@/lib/audit'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
+import { canEditCase } from '@/lib/access/caseWrite'
+import { AccessError, must } from '@/lib/errors'
+import { loadVisibleCase } from '@/lib/cases/service'
+import type { LinkKindName } from '@/lib/cases/terms'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Verknüpfungen zwischen Akten.
+ *
+ * Die Richtung trägt Bedeutung: `SUCCESSOR` und `MERGED_INTO` sagen etwas
+ * anderes, je nachdem, von welcher Seite man liest. `RELATED` ist symmetrisch.
+ *
+ * Beide Seiten laufen durch die Sichtbarkeitsprüfung. Eine Akte, die der Leser
+ * nicht sehen darf, taucht auch als Verknüpfung nicht auf — sonst verriete die
+ * Gegenseite ihre Existenz. Das gilt in **beide** Richtungen, deshalb wird der
+ * Filter zweimal angewandt.
+ */
+
+const AKTE = {
+  id: true,
+  caseNumber: true,
+  title: true,
+  status: true,
+  classification: true,
+  updatedAt: true,
+} as const
+
+/** Alle Verknüpfungen einer Akte, aus beiden Richtungen, gefiltert. */
+export async function listLinks(p: EffectivePermissions, caseId: string) {
+  const sichtbar = visibleCaseWhere(p)
+
+  const [hinaus, herein] = await Promise.all([
+    db.caseLink.findMany({
+      where: { AND: [{ fromId: caseId }, { to: { is: sichtbar } }] },
+      select: { kind: true, createdAt: true, to: { select: AKTE } },
+      orderBy: { createdAt: 'desc' },
+    }),
+    db.caseLink.findMany({
+      where: { AND: [{ toId: caseId }, { from: { is: sichtbar } }] },
+      select: { kind: true, createdAt: true, from: { select: AKTE } },
+      orderBy: { createdAt: 'desc' },
+    }),
+  ])
+
+  return [
+    ...hinaus.map((link) => ({
+      kind: link.kind,
+      direction: 'out' as const,
+      other: link.to,
+      createdAt: link.createdAt,
+    })),
+    ...herein.map((link) => ({
+      kind: link.kind,
+      direction: 'in' as const,
+      other: link.from,
+      createdAt: link.createdAt,
+    })),
+  ]
+}
+
+export async function linkCases(
+  p: EffectivePermissions,
+  input: { fromCaseNumber: string; toCaseNumber: string; kind: LinkKindName },
+): Promise<void> {
+  const from = await loadVisibleCase(p, input.fromCaseNumber)
+  if (!from) throw new AccessError('not-found')
+  must(canEditCase(p, from))
+
+  const to = await loadVisibleCase(p, input.toCaseNumber.trim())
+  if (!to) throw new AccessError('not-found')
+  if (to.id === from.id) throw new AccessError('link-self')
+
+  await db.$transaction(async (tx) => {
+    await tx.caseLink.upsert({
+      where: { fromId_toId_kind: { fromId: from.id, toId: to.id, kind: input.kind } },
+      create: { fromId: from.id, toId: to.id, kind: input.kind, createdById: p.userId },
+      update: {},
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'case.link',
+      targetType: 'Case',
+      targetId: from.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { from: from.caseNumber, to: to.caseNumber, kind: input.kind },
+    })
+  })
+}
+
+/**
+ * Verknüpfung lösen. Umkehrbar und deshalb ohne Bestätigungsdialog, siehe
+ * docs/09-performance-und-ux.md. Das Protokoll behält sie.
+ */
+export async function unlinkCases(
+  p: EffectivePermissions,
+  input: { fromCaseNumber: string; toCaseNumber: string; kind: LinkKindName },
+): Promise<void> {
+  const from = await loadVisibleCase(p, input.fromCaseNumber)
+  if (!from) throw new AccessError('not-found')
+  must(canEditCase(p, from))
+
+  const to = await loadVisibleCase(p, input.toCaseNumber)
+  if (!to) throw new AccessError('not-found')
+
+  await db.$transaction(async (tx) => {
+    await tx.caseLink.deleteMany({
+      where: {
+        OR: [
+          { fromId: from.id, toId: to.id, kind: input.kind },
+          { fromId: to.id, toId: from.id, kind: input.kind },
+        ],
+      },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'case.unlink',
+      targetType: 'Case',
+      targetId: from.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { from: from.caseNumber, to: to.caseNumber, kind: input.kind },
+    })
+  })
+}

web/lib/cases/participants.ts

@@ -0,0 +1,183 @@
+import { db } from '@/lib/db'
+import { writeAudit } from '@/lib/audit'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
+import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
+import { canEditCase } from '@/lib/access/caseWrite'
+import { AccessError, must } from '@/lib/errors'
+import { loadVisibleCase } from '@/lib/cases/service'
+import type { ParticipantRoleName } from '@/lib/cases/terms'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Beteiligte einer Akte.
+ *
+ * Zwei Dinge zugleich: eine fachliche Angabe („wer ist Zeuge") und der Weg zum
+ * **ausnahmsweisen Zugang**. Wer als Beteiligter eingetragen ist, liest die
+ * Akte unabhängig von seiner Freigabestufe. Das ist der vorgesehene Weg,
+ * jemanden gezielt hinzuzuziehen, ohne ihm allgemein eine höhere Stufe zu
+ * geben. Es setzt `case.edit` voraus und wird protokolliert.
+ * Siehe docs/03-auth-und-rechte.md.
+ */
+
+export async function listParticipants(p: EffectivePermissions, caseId: string) {
+  const rows = await db.caseParticipant.findMany({
+    where: { AND: [{ caseId }, { case: { is: visibleCaseWhere(p) } }] },
+    orderBy: { createdAt: 'asc' },
+    select: {
+      id: true,
+      role: true,
+      createdAt: true,
+      addedById: true,
+      user: { select: { id: true, displayName: true } },
+      // Die Personalakte kommt nur mit, wenn der Leser sie sehen darf. Sonst
+      // steht der Name da, aber der Verweis führt ins Leere — das ist richtig
+      // so: der Beteiligte ist Teil der Akte, seine Personalakte nicht.
+      personnelFile: { select: { id: true, displayName: true } },
+    },
+  })
+
+  const sichtbareAkten = new Set(
+    (
+      await db.personnelFile.findMany({
+        where: {
+          AND: [
+            visiblePersonnelWhere(p),
+            {
+              id: {
+                in: rows.flatMap((row) => (row.personnelFile ? [row.personnelFile.id] : [])),
+              },
+            },
+          ],
+        },
+        select: { id: true },
+      })
+    ).map((row) => row.id),
+  )
+
+  return rows.map((row) => ({
+    id: row.id,
+    role: row.role,
+    createdAt: row.createdAt,
+    userId: row.user?.id ?? null,
+    displayName: row.user?.displayName ?? row.personnelFile?.displayName ?? null,
+    personnelFileId:
+      row.personnelFile && sichtbareAkten.has(row.personnelFile.id) ? row.personnelFile.id : null,
+  }))
+}
+
+/**
+ * Trägt einen Beteiligten ein. Entweder ein Discord-Konto oder eine
+ * Personalakte, nicht beides und nicht keins.
+ */
+export async function addParticipant(
+  p: EffectivePermissions,
+  input: {
+    caseNumber: string
+    role: ParticipantRoleName
+    userId?: string | null
+    personnelFileId?: string | null
+  },
+): Promise<{ id: string }> {
+  const target = await loadVisibleCase(p, input.caseNumber)
+  if (!target) throw new AccessError('not-found')
+  must(canEditCase(p, target))
+
+  const userId = input.userId || null
+  const personnelFileId = input.personnelFileId || null
+  if ((userId === null) === (personnelFileId === null)) throw new AccessError('participant-target')
+
+  if (userId) {
+    const vorhanden = await db.user.findUnique({ where: { id: userId }, select: { id: true } })
+    if (!vorhanden) throw new AccessError('not-found')
+  }
+  if (personnelFileId) {
+    // Eine Personalakte, die der Eintragende nicht sehen darf, kann er auch
+    // nicht als Beteiligte setzen — sonst verrät ihm die Fehlermeldung ihre
+    // Existenz.
+    const akte = await db.personnelFile.findFirst({
+      where: { AND: [visiblePersonnelWhere(p), { id: personnelFileId }] },
+      select: { id: true },
+    })
+    if (!akte) throw new AccessError('not-found')
+  }
+
+  const bereitsDa = await db.caseParticipant.findFirst({
+    where: { caseId: target.id, role: input.role, userId, personnelFileId },
+    select: { id: true },
+  })
+  if (bereitsDa) return bereitsDa
+
+  return db.$transaction(async (tx) => {
+    const created = await tx.caseParticipant.create({
+      data: { caseId: target.id, role: input.role, userId, personnelFileId, addedById: p.userId },
+      select: { id: true },
+    })
+
+    // Sichtbar im Verlauf, nicht nur im Protokoll: dass jemand Zugang zu einer
+    // Akte bekommt, geht alle an, die die Akte lesen.
+    await tx.caseEntry.create({
+      data: {
+        id: crypto.randomUUID(),
+        caseId: target.id,
+        type: 'SYSTEM',
+        body: `Beteiligte eingetragen: ${input.role}`,
+        authorId: p.userId,
+        minClearance: 0,
+      },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'case.participant.add',
+      targetType: 'CaseParticipant',
+      targetId: created.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        caseNumber: target.caseNumber,
+        role: input.role,
+        userId: userId ?? undefined,
+        personnelFileId: personnelFileId ?? undefined,
+      },
+    })
+
+    return created
+  })
+}
+
+/**
+ * Entfernt einen Beteiligten. Anders als ein Verlaufseintrag ist das keine
+ * Aussage über den Sachverhalt, sondern eine Zuständigkeit — sie darf
+ * verschwinden. Das Protokoll behält sie.
+ */
+export async function removeParticipant(
+  p: EffectivePermissions,
+  input: { caseNumber: string; participantId: string },
+): Promise<void> {
+  const target = await loadVisibleCase(p, input.caseNumber)
+  if (!target) throw new AccessError('not-found')
+  must(canEditCase(p, target))
+
+  const teilnehmer = await db.caseParticipant.findFirst({
+    where: { id: input.participantId, caseId: target.id },
+    select: { id: true, role: true, userId: true, personnelFileId: true },
+  })
+  if (!teilnehmer) throw new AccessError('not-found')
+
+  await db.$transaction(async (tx) => {
+    await tx.caseParticipant.delete({ where: { id: teilnehmer.id } })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'case.participant.remove',
+      targetType: 'CaseParticipant',
+      targetId: teilnehmer.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        caseNumber: target.caseNumber,
+        role: teilnehmer.role,
+        userId: teilnehmer.userId ?? undefined,
+        personnelFileId: teilnehmer.personnelFileId ?? undefined,
+      },
+    })
+  })
+}

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) {

web/lib/cases/service.ts

@@ -2,8 +2,9 @@ import { db } from '@/lib/db'
 import { writeAudit } from '@/lib/audit'
 import { visibleCaseWhere } from '@/lib/access/caseFilter'
 import { canCreateCase, canEditCase, canReclassify } from '@/lib/access/caseWrite'
-import { nextCaseNumber } from '@/lib/cases/caseNumber'
+import { nextNumber } from '@/lib/numbering'
 import { findTransition, type CaseStatusName } from '@/lib/cases/lifecycle'
+import { AccessError, must } from '@/lib/errors'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 
 /**
@@ -14,16 +15,7 @@ import type { EffectivePermissions } from '@/lib/auth/permissions'
  * und geben zurück. Die Regeln stehen an genau einer Stelle.
  */
 
-export class AccessError extends Error {
-  constructor(readonly code: string) {
-    super(code)
-    this.name = 'AccessError'
-  }
-}
-
-function must(check: { ok: boolean; reason?: string }): void {
-  if (!check.ok) throw new AccessError(check.reason ?? 'denied')
-}
+export { AccessError } from '@/lib/errors'
 
 /** Lädt eine Akte, sofern der Nutzer sie sehen darf. Sonst `null` — nie 403. */
 export async function loadVisibleCase(p: EffectivePermissions, caseNumber: string) {
@@ -53,7 +45,7 @@ export async function createCase(
 ): Promise<{ caseNumber: string; id: string }> {
   must(canCreateCase(p, input.classification))
 
-  const template = await db.caseTemplate.findFirst({
+  const template = await db.documentTemplate.findFirst({
     where: { key: input.templateKey, isActive: true },
     orderBy: { version: 'desc' },
     select: { id: true, key: true, numberPrefix: true, numberPadding: true },
@@ -62,7 +54,7 @@ export async function createCase(
 
   return db.$transaction(async (tx) => {
     // Das Muster kommt aus der Vorlage, jede Fallart hat ihren Nummernkreis.
-    const caseNumber = await nextCaseNumber(tx, {
+    const caseNumber = await nextNumber(tx, {
       prefix: template.numberPrefix,
       padding: template.numberPadding,
     })
@@ -263,7 +255,7 @@ export async function reclassify(
 
 /** Felder mit `requiredToClose`, die noch leer sind. Kommt mit Phase 3 zum Tragen. */
 async function missingRequiredSections(caseId: string, templateId: string): Promise<string[]> {
-  const template = await db.caseTemplate.findUnique({
+  const template = await db.documentTemplate.findUnique({
     where: { id: templateId },
     select: { fields: true },
   })

web/lib/cases/terms.ts

@@ -0,0 +1,34 @@
+/**
+ * Feste Wertelisten der Akte — Rollen der Beteiligten und Arten der
+ * Verknüpfung.
+ *
+ * **Ohne Abhängigkeiten.** Diese Datei wird auch im Client geladen, und die
+ * Dienstmodule daneben ziehen den Datenbankclient nach sich. Denselben Schnitt
+ * hat `lib/templates/fields.ts` gegenüber `schema.ts`, aus demselben Grund:
+ * das Bündelbudget aus docs/09-performance-und-ux.md.
+ *
+ * Die Übersetzungen stehen in `lib/i18n/de.ts`, nicht hier: diese Namen sind
+ * Datenbankwerte.
+ */
+
+export const PARTICIPANT_ROLES = [
+  'LEAD',
+  'INVESTIGATOR',
+  'WITNESS',
+  'SUBJECT',
+  'OBSERVER',
+] as const
+
+export type ParticipantRoleName = (typeof PARTICIPANT_ROLES)[number]
+
+export function isParticipantRole(value: string): value is ParticipantRoleName {
+  return (PARTICIPANT_ROLES as readonly string[]).includes(value)
+}
+
+export const LINK_KINDS = ['RELATED', 'SUCCESSOR', 'MERGED_INTO'] as const
+
+export type LinkKindName = (typeof LINK_KINDS)[number]
+
+export function isLinkKind(value: string): value is LinkKindName {
+  return (LINK_KINDS as readonly string[]).includes(value)
+}