Phase 8 abgeschlossen: Export als PDF, Wasserzeichen, Vier-Augen-Freigabe

Die Druckansicht ist die einzige Vorlage für den Export: kein zweites Layout
von Hand in einer PDF-Bibliothek. Der Playwright-Dienst ruft genau diese Seite
auf und bekommt dafür ein signiertes, kurzlebiges Zeichen statt eines
Sitzungscookies. Es gilt nur, solange der Auftrag läuft, ist an den Anfragenden
gebunden, und die Stufe wird beim Einlösen frisch aufgelöst und auf die im
Zeichen vermerkte gedeckelt.

Der Export darf nie sauberer aussehen als die Akte: gesperrte Felder erscheinen
als Balken mit Vermerk statt zu fehlen, geänderte Einträge tragen ihre Version,
zurückgezogene stehen als Grabstein. Wasserzeichen mit Name, Zeitstempel und
Stufe auf jeder Seite.

Die Stufe steckt im Zwischenspeicherschlüssel. Ohne sie bekäme ein Leser der
Stufe 1 das PDF, das für Stufe 4 gerendert wurde.

Ab Stufe 3 wartet der Auftrag auf Freigabe durch ein zweites Augenpaar - und
der Anfragende darf sich nicht selbst freigeben, auch nicht mit dem Recht
dazu. Offene Freigaben stehen auf der Übersicht.

Dazu Einzeldokumente als PDF (Aktenblatt bleibt Aktenblatt), ZIP-Sammelexport
mit eigenem achtzigzeiligem Schreiber statt einer Abhängigkeit, und der
JSON-Vollabzug ohne Stufenfilterung - die einzige Stelle, an der die
Klassifizierung nicht greift, deshalb hinter einem eigenen Admin-Endpunkt.

Zwei Funde unterwegs, beide in docs/13 festgehalten:

Die Druckansicht warf notFound(), und das Skelett aus dem Wurzel-loading.tsx
blieb im Browser stehen - der PDF-Dienst hätte leere Blätter gedruckt.
Gefunden nur, weil der e2e-Test auf den Inhalt prüft und nicht auf den
Statuscode. Sie rendert die Auskunft jetzt selbst.

Und die Entdopplung der Anhänge verwies auf Dateien, ohne nachzusehen, ob sie
noch daliegen. Nach einem geleerten /tmp zeigte jeder weitere Upload desselben
Inhalts stumm ins Leere.

178 Tests im Web-Paket, 17 in der Datenbank, 7 im Worker, 44 e2e.
Fallakte bei 119,8 von 120 kB - das Budget ist aufgebraucht.

web/lib/export/cacheKey.ts

@@ -0,0 +1,32 @@
+import { createHash } from 'node:crypto'
+
+/**
+ * Der Zwischenspeicherschlüssel eines Exports.
+ *
+ * `sha256(Ziel + Stand + Stufe + Vorlagenversion)`, siehe docs/08. Die
+ * **Stufe gehört hinein**: zwei Abrufer verschiedener Stufen bekommen nicht
+ * dasselbe PDF, und ein Treffer im Zwischenspeicher darf niemandem ein
+ * Dokument geben, das für eine höhere Stufe gerendert wurde.
+ *
+ * Der Stand (`updatedAt`) sorgt dafür, dass eine geänderte Akte neu gerendert
+ * wird — ein Export darf nie einen älteren Stand zeigen, als die Akte hat.
+ */
+export function exportCacheKey(input: {
+  kind: string
+  targetId: string
+  updatedAt: Date
+  clearanceLevel: number
+  templateVersion: number | string
+}): string {
+  return createHash('sha256')
+    .update(
+      [
+        input.kind,
+        input.targetId,
+        input.updatedAt.toISOString(),
+        String(input.clearanceLevel),
+        String(input.templateVersion),
+      ].join('|'),
+    )
+    .digest('hex')
+}

web/lib/export/database.ts

@@ -0,0 +1,122 @@
+import { db } from '@/lib/db'
+import { writeAudit } from '@/lib/audit'
+import { AccessError } from '@/lib/errors'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Vollständiger JSON-Abzug als Umzugs- und Notfallformat.
+ *
+ * **Ohne Stufenfilterung**, nur mit Recht `admin`, immer protokolliert — so
+ * steht es in docs/08-suche-und-export.md. Das ist die eine Stelle im System,
+ * an der die Klassifizierung nicht greift, und sie ist deshalb absichtlich
+ * unbequem: kein Knopf an einer Akte, sondern eine eigene Seite im
+ * Adminbereich.
+ *
+ * Ausgelassen wird, was Zugang verschafft statt ihn zu dokumentieren:
+ * Sitzungen. Sie gehören niemandem ausser dem Browser, aus dem sie stammen.
+ */
+export async function exportDatabase(p: EffectivePermissions): Promise<Uint8Array> {
+  if (!p.isAdmin) throw new AccessError('no-permission')
+
+  const [
+    users,
+    roleMappings,
+    clearanceLevels,
+    foundationClearances,
+    statusTags,
+    templates,
+    cases,
+    caseSections,
+    caseSectionVersions,
+    caseEntries,
+    caseEntryVersions,
+    participants,
+    exclusions,
+    links,
+    personnel,
+    assignments,
+    documents,
+    documentSections,
+    documentSectionVersions,
+    attachments,
+    channels,
+    messages,
+    reactions,
+    auditLog,
+  ] = await Promise.all([
+    db.user.findMany(),
+    db.roleMapping.findMany(),
+    db.clearanceLevelConfig.findMany(),
+    db.foundationClearance.findMany(),
+    db.personnelStatusTag.findMany(),
+    db.documentTemplate.findMany(),
+    db.case.findMany(),
+    db.caseSection.findMany(),
+    db.caseSectionVersion.findMany(),
+    db.caseEntry.findMany(),
+    db.caseEntryVersion.findMany(),
+    db.caseParticipant.findMany(),
+    db.caseExclusion.findMany(),
+    db.caseLink.findMany(),
+    db.personnelFile.findMany(),
+    db.personnelAssignment.findMany(),
+    db.document.findMany(),
+    db.documentSection.findMany(),
+    db.documentSectionVersion.findMany(),
+    db.attachment.findMany(),
+    db.channel.findMany(),
+    db.chatMessage.findMany(),
+    db.chatReaction.findMany(),
+    // Das Protokoll gehört dazu: ein Abzug ohne die Zugriffsspur wäre als
+    // Notfallformat wertlos.
+    db.auditLog.findMany({ orderBy: { id: 'desc' }, take: 50_000 }),
+  ])
+
+  const abzug = {
+    exportedAt: new Date().toISOString(),
+    exportedBy: p.userId,
+    note: 'Vollstaendiger Abzug ohne Stufenfilterung. Vertraulich behandeln.',
+    users,
+    roleMappings,
+    clearanceLevels,
+    foundationClearances,
+    statusTags,
+    templates,
+    cases,
+    caseSections,
+    caseSectionVersions,
+    caseEntries,
+    caseEntryVersions,
+    participants,
+    exclusions,
+    links,
+    personnel,
+    assignments,
+    documents,
+    documentSections,
+    documentSectionVersions,
+    attachments,
+    channels,
+    messages,
+    reactions,
+    auditLog,
+  }
+
+  await db.$transaction(async (tx) => {
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'export.database',
+      targetType: 'Database',
+      targetId: 'all',
+      clearanceAtTime: p.clearanceLevel,
+      meta: { cases: cases.length, entries: caseEntries.length, users: users.length },
+    })
+  })
+
+  // `BigInt` kommt in AuditLog.id vor und ist in JSON nicht vorgesehen.
+  return new TextEncoder().encode(
+    JSON.stringify(abzug, (_key, wert: unknown) =>
+      typeof wert === 'bigint' ? wert.toString() : wert,
+    2),
+  )
+}

web/lib/export/printAccess.ts

@@ -0,0 +1,18 @@
+import { getCurrentUser } from '@/lib/auth/current'
+import { permissionsFromRenderToken } from '@/lib/export/renderAccess'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Die Druckansicht dient zwei Aufrufern: dem PDF-Dienst mit Zeichen und einem
+ * Menschen, der sie sich ansieht. Diese Funktion steht in einer eigenen Datei,
+ * weil sie `next-auth` lädt — der Zeichenpfad soll das nicht müssen.
+ */
+export async function permissionsForPrint(
+  token: string | null | undefined,
+): Promise<{ permissions: EffectivePermissions; displayName: string } | null> {
+  if (token) return permissionsFromRenderToken(token)
+
+  const user = await getCurrentUser()
+  if (!user) return null
+  return { permissions: user.permissions, displayName: user.displayName }
+}

web/lib/export/renderAccess.ts

@@ -0,0 +1,48 @@
+import { db } from '@/lib/db'
+import { verifyRenderToken } from '@/lib/export/token'
+import { resolvePermissions } from '@/lib/auth/effective'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Wer die Druckansicht sehen darf.
+ *
+ * Zwei Wege: die angemeldete Person selbst, oder der PDF-Dienst mit einem
+ * kurzlebigen Zeichen, das für **genau diesen Auftrag** ausgestellt wurde.
+ *
+ * Die Stufe kommt dabei nicht aus dem Zeichen, sondern wird frisch aufgelöst
+ * und dann auf die im Zeichen vermerkte **gedeckelt**. Damit kann ein Zeichen
+ * nie mehr zeigen, als der Abrufer beim Anfragen sehen durfte — und auch nicht
+ * mehr, als er jetzt noch darf, falls ihm inzwischen Rechte entzogen wurden.
+ */
+export async function permissionsFromRenderToken(
+  token: string | null | undefined,
+): Promise<{ permissions: EffectivePermissions; displayName: string } | null> {
+  const claim = verifyRenderToken(token)
+
+  {
+    if (!claim) return null
+    const auftrag = await db.exportJob.findUnique({
+      where: { id: claim.jobId },
+      select: { status: true, requestedById: true },
+    })
+    // Nur solange der Auftrag wirklich läuft. Ein Zeichen aus einem
+    // abgeschlossenen oder abgelehnten Auftrag taugt zu nichts.
+    if (!auftrag || auftrag.status !== 'RUNNING') return null
+    if (auftrag.requestedById !== claim.userId) return null
+
+    const nutzer = await db.user.findUnique({
+      where: { id: claim.userId },
+      select: { displayName: true, isActive: true },
+    })
+    if (!nutzer?.isActive) return null
+
+    const aktuell = await resolvePermissions(claim.userId)
+    return {
+      permissions: {
+        ...aktuell,
+        clearanceLevel: Math.min(aktuell.clearanceLevel, claim.clearanceLevel),
+      },
+      displayName: nutzer.displayName,
+    }
+  }
+}

web/lib/export/service.ts

@@ -0,0 +1,364 @@
+import { writeFile } from 'node:fs/promises'
+import { db } from '@/lib/db'
+import { getEnv } from '@/lib/env'
+import { writeAudit, READ_AUDIT_FROM_LEVEL } from '@/lib/audit'
+import { AccessError } from '@/lib/errors'
+import { loadVisibleCase } from '@/lib/cases/service'
+import { loadVisibleDocument } from '@/lib/documents/service'
+import { ensureDirFor, storageKeyFor } from '@/lib/files/paths'
+import { exportCacheKey } from '@/lib/export/cacheKey'
+import { createRenderToken } from '@/lib/export/token'
+import { publish, userTopic } from '@/lib/realtime/publish'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Exportaufträge.
+ *
+ * Drei Regeln aus docs/08-suche-und-export.md, und alle drei stecken hier:
+ *
+ *  1. **Der Export respektiert die Stufe des Abrufers.** Die Druckansicht
+ *     rendert mit seinen Rechten, gesperrte Felder erscheinen als Schwärzung
+ *     mit Vermerk — nicht weggelassen, sonst merkt der Empfänger nicht, dass
+ *     er eine gekürzte Fassung hat.
+ *  2. **Wasserzeichen** auf jeder Seite: Name, Zeitstempel, Stufe.
+ *  3. **Jeder Export wird protokolliert**, und ab Stufe 3 braucht er die
+ *     Freigabe durch ein zweites Augenpaar.
+ */
+
+/** Ab dieser Klassifizierung braucht ein Export eine zweite Unterschrift. */
+export const APPROVAL_FROM_LEVEL = READ_AUDIT_FROM_LEVEL
+
+export type ExportTarget =
+  | { kind: 'CASE'; caseNumber: string }
+  | { kind: 'DOCUMENT'; documentNumber: string }
+
+/**
+ * Legt einen Auftrag an — oder gibt einen fertigen zurück, wenn genau dieser
+ * Stand schon einmal für diese Stufe gerendert wurde.
+ */
+export async function requestExport(
+  p: EffectivePermissions,
+  target: ExportTarget,
+): Promise<{ jobId: string; status: string }> {
+  const ziel = await aufloesen(p, target)
+
+  const cacheKey = exportCacheKey({
+    kind: target.kind,
+    targetId: ziel.id,
+    updatedAt: ziel.updatedAt,
+    clearanceLevel: p.clearanceLevel,
+    templateVersion: ziel.templateVersion,
+  })
+
+  // Derselbe Stand, dieselbe Stufe: das PDF liegt schon da.
+  const fertig = await db.exportJob.findFirst({
+    where: { cacheKey, status: 'READY' },
+    select: { id: true },
+  })
+  if (fertig) {
+    await protokolliere(p, 'export.pdf', ziel.id, { cached: true, kind: target.kind })
+    return { jobId: fertig.id, status: 'READY' }
+  }
+
+  // Läuft schon einer für denselben Stand? Dann daran hängen.
+  const laufend = await db.exportJob.findFirst({
+    where: { cacheKey, status: { in: ['QUEUED', 'RUNNING', 'PENDING_APPROVAL'] } },
+    select: { id: true, status: true },
+  })
+  if (laufend) return { jobId: laufend.id, status: laufend.status }
+
+  const brauchtFreigabe = ziel.classification >= APPROVAL_FROM_LEVEL
+
+  const auftrag = await db.$transaction(async (tx) => {
+    const angelegt = await tx.exportJob.create({
+      data: {
+        kind: target.kind,
+        targetId: ziel.id,
+        requestedById: p.userId,
+        clearanceAtTime: p.clearanceLevel,
+        cacheKey,
+        status: brauchtFreigabe ? 'PENDING_APPROVAL' : 'QUEUED',
+      },
+      select: { id: true, status: true },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'export.pdf',
+      targetType: target.kind === 'CASE' ? 'Case' : 'Document',
+      targetId: ziel.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        jobId: angelegt.id,
+        label: ziel.label,
+        classification: ziel.classification,
+        needsApproval: brauchtFreigabe,
+      },
+    })
+
+    return angelegt
+  })
+
+  return { jobId: auftrag.id, status: auftrag.status }
+}
+
+async function aufloesen(p: EffectivePermissions, target: ExportTarget) {
+  if (target.kind === 'CASE') {
+    const akte = await loadVisibleCase(p, target.caseNumber)
+    if (!akte) throw new AccessError('not-found')
+    const vorlage = await db.documentTemplate.findUnique({
+      where: { id: akte.templateId },
+      select: { version: true },
+    })
+    return {
+      id: akte.id,
+      label: akte.caseNumber,
+      classification: akte.classification,
+      updatedAt: akte.updatedAt,
+      templateVersion: vorlage?.version ?? 0,
+      printPath: `/faelle/${akte.caseNumber}/druck`,
+    }
+  }
+
+  const doc = await loadVisibleDocument(p, target.documentNumber)
+  if (!doc) throw new AccessError('not-found')
+  return {
+    id: doc.id,
+    label: doc.documentNumber,
+    classification: doc.classification,
+    updatedAt: doc.updatedAt,
+    templateVersion: doc.templateVersion,
+    printPath: `/dokumente/${doc.documentNumber}/druck`,
+  }
+}
+
+/**
+ * Freigabe durch ein zweites Augenpaar.
+ *
+ * **Nicht durch den Anfragenden selbst** — sonst wäre es keins. Das ist der
+ * einzige Grund, warum es die Prüfung überhaupt gibt.
+ */
+export async function approveExport(
+  p: EffectivePermissions,
+  jobId: string,
+): Promise<void> {
+  if (!p.isAdmin && !p.permissions.has('export.approve')) {
+    throw new AccessError('no-permission')
+  }
+
+  const auftrag = await db.exportJob.findUnique({
+    where: { id: jobId },
+    select: { id: true, status: true, requestedById: true, targetId: true, kind: true },
+  })
+  if (!auftrag) throw new AccessError('not-found')
+  if (auftrag.status !== 'PENDING_APPROVAL') throw new AccessError('export-not-pending')
+  if (auftrag.requestedById === p.userId) throw new AccessError('export-self-approval')
+
+  await db.$transaction(async (tx) => {
+    await tx.exportJob.update({
+      where: { id: jobId },
+      data: { status: 'QUEUED', approvedById: p.userId, approvedAt: new Date() },
+    })
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'export.approve',
+      targetType: 'ExportJob',
+      targetId: jobId,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { requestedBy: auftrag.requestedById, kind: auftrag.kind },
+    })
+  })
+}
+
+export async function rejectExport(
+  p: EffectivePermissions,
+  jobId: string,
+  reason: string,
+): Promise<void> {
+  if (!p.isAdmin && !p.permissions.has('export.approve')) {
+    throw new AccessError('no-permission')
+  }
+  const begruendung = reason.trim()
+  if (begruendung.length < 10) throw new AccessError('reason-required')
+
+  await db.$transaction(async (tx) => {
+    await tx.exportJob.updateMany({
+      where: { id: jobId, status: 'PENDING_APPROVAL' },
+      data: { status: 'REJECTED', rejectedById: p.userId, rejectReason: begruendung },
+    })
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'export.reject',
+      targetType: 'ExportJob',
+      targetId: jobId,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { reason: begruendung },
+    })
+  })
+}
+
+/**
+ * Führt einen freigegebenen Auftrag aus: Druckansicht rendern lassen, ablegen,
+ * melden.
+ *
+ * Läuft im Hintergrund, nach der Antwort. Der PDF-Dienst bekommt ein
+ * kurzlebiges Zeichen statt eines Sitzungscookies, siehe `token.ts`.
+ */
+export async function runExport(jobId: string): Promise<void> {
+  const auftrag = await db.exportJob.findUnique({ where: { id: jobId } })
+  if (!auftrag || auftrag.status !== 'QUEUED') return
+
+  await db.exportJob.update({
+    where: { id: jobId },
+    data: { status: 'RUNNING', startedAt: new Date() },
+  })
+
+  try {
+    const pfad = await druckPfad(auftrag.kind, auftrag.targetId)
+    if (!pfad) throw new Error('Ziel nicht mehr vorhanden')
+
+    const env = getEnv()
+    if (!env.PDF_SERVICE_URL) throw new Error('PDF_SERVICE_URL ist nicht gesetzt')
+
+    const nutzer = await db.user.findUnique({
+      where: { id: auftrag.requestedById },
+      select: { displayName: true },
+    })
+
+    const token = createRenderToken({
+      jobId,
+      userId: auftrag.requestedById,
+      clearanceLevel: auftrag.clearanceAtTime,
+    })
+    const url = `${env.APP_URL.replace(/\/$/, '')}${pfad}?token=${encodeURIComponent(token)}`
+
+    const antwort = await fetch(`${env.PDF_SERVICE_URL.replace(/\/$/, '')}/render`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        url,
+        // Wasserzeichen auf jeder Seite, siehe docs/08. Es steht im
+        // Seitenkopf, damit es nicht im Inhalt untergeht.
+        headerHtml: wasserzeichen(
+          nutzer?.displayName ?? auftrag.requestedById,
+          auftrag.clearanceAtTime,
+        ),
+        footerHtml:
+          '<div style="width:100%;font-size:7pt;font-family:monospace;padding:0 16mm;' +
+          'display:flex;justify-content:space-between;color:#444">' +
+          '<span class="date"></span><span><span class="pageNumber"></span>/<span class="totalPages"></span></span>' +
+          '</div>',
+      }),
+    })
+
+    if (!antwort.ok) {
+      throw new Error(`PDF-Dienst antwortete mit ${antwort.status}`)
+    }
+
+    const inhalt = new Uint8Array(await antwort.arrayBuffer())
+    const storageKey = storageKeyFor('store', `export-${jobId}`)
+    await writeFile(await ensureDirFor(storageKey), inhalt)
+
+    await db.exportJob.update({
+      where: { id: jobId },
+      data: {
+        status: 'READY',
+        storageKey,
+        sizeBytes: inhalt.byteLength,
+        finishedAt: new Date(),
+      },
+    })
+  } catch (error) {
+    await db.exportJob.update({
+      where: { id: jobId },
+      data: {
+        status: 'FAILED',
+        error: error instanceof Error ? error.message.slice(0, 300) : 'unbekannt',
+        finishedAt: new Date(),
+      },
+    })
+  }
+
+  await publish(userTopic(auftrag.requestedById), 'export.ready', jobId)
+}
+
+function wasserzeichen(name: string, stufe: number): string {
+  const sicher = name.replace(/[<>&]/g, '')
+  return (
+    '<div style="width:100%;font-size:7pt;font-family:monospace;padding:0 16mm;' +
+    'display:flex;justify-content:space-between;color:#666">' +
+    `<span>${sicher} · Stufe ${stufe}</span>` +
+    '<span class="date"></span>' +
+    '</div>'
+  )
+}
+
+async function druckPfad(kind: string, targetId: string | null): Promise<string | null> {
+  if (!targetId) return null
+  if (kind === 'CASE') {
+    const akte = await db.case.findUnique({
+      where: { id: targetId },
+      select: { caseNumber: true },
+    })
+    return akte ? `/faelle/${akte.caseNumber}/druck` : null
+  }
+  const doc = await db.document.findUnique({
+    where: { id: targetId },
+    select: { documentNumber: true },
+  })
+  return doc ? `/dokumente/${doc.documentNumber}/druck` : null
+}
+
+async function protokolliere(
+  p: EffectivePermissions,
+  action: 'export.pdf',
+  targetId: string,
+  meta: Record<string, unknown>,
+): Promise<void> {
+  await db.$transaction(async (tx) => {
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action,
+      targetType: 'ExportJob',
+      targetId,
+      clearanceAtTime: p.clearanceLevel,
+      meta: meta as never,
+    })
+  })
+}
+
+/** Der Auftrag, sofern er dem Abrufer gehört. */
+export async function loadJob(p: EffectivePermissions, jobId: string) {
+  return db.exportJob.findFirst({
+    where: { id: jobId, requestedById: p.userId },
+    select: {
+      id: true,
+      kind: true,
+      status: true,
+      sizeBytes: true,
+      error: true,
+      rejectReason: true,
+      createdAt: true,
+      finishedAt: true,
+    },
+  })
+}
+
+/** Offene Freigaben für das Dashboard des Leiters. */
+export async function pendingApprovals(p: EffectivePermissions) {
+  if (!p.isAdmin && !p.permissions.has('export.approve')) return []
+
+  return db.exportJob.findMany({
+    where: { status: 'PENDING_APPROVAL', requestedById: { not: p.userId } },
+    orderBy: { createdAt: 'asc' },
+    take: 20,
+    select: {
+      id: true,
+      kind: true,
+      targetId: true,
+      requestedById: true,
+      clearanceAtTime: true,
+      createdAt: true,
+    },
+  })
+}

web/lib/export/token.ts

@@ -0,0 +1,62 @@
+import { createHmac, timingSafeEqual } from 'node:crypto'
+import { getEnv } from '@/lib/env'
+
+/**
+ * Kurzlebiges Zeichen für den Druckabruf.
+ *
+ * Der PDF-Dienst ruft die Druckansicht selbst auf und braucht dafür die Rechte
+ * des Abrufers. Ihm dafür das **Sitzungscookie** mitzugeben wäre der bequeme
+ * Weg und der falsche: ein Cookie ist der volle Zugang zum Konto, und es läge
+ * dann im Speicher eines zweiten Prozesses und in dessen Protokollen.
+ *
+ * Stattdessen ein signiertes Zeichen, das genau eines erlaubt: diese eine
+ * Ansicht, für diesen einen Auftrag, für ein paar Minuten. Es taugt zu nichts
+ * anderem. Vergleichbar mit der signierten Datei-URL aus docs/07.
+ */
+
+/** Lange genug für einen langsamen Rendervorgang, kurz genug zum Wegwerfen. */
+const GUELTIG_MS = 10 * 60_000
+
+export type RenderClaim = {
+  jobId: string
+  userId: string
+  clearanceLevel: number
+  expiresAt: number
+}
+
+function signieren(nutzlast: string): string {
+  return createHmac('sha256', getEnv().AUTH_SECRET).update(nutzlast).digest('base64url')
+}
+
+export function createRenderToken(claim: Omit<RenderClaim, 'expiresAt'>): string {
+  const vollstaendig: RenderClaim = { ...claim, expiresAt: Date.now() + GUELTIG_MS }
+  const nutzlast = Buffer.from(JSON.stringify(vollstaendig)).toString('base64url')
+  return `${nutzlast}.${signieren(nutzlast)}`
+}
+
+/**
+ * Prüft das Zeichen. Gibt `null` zurück, wenn irgendetwas nicht stimmt — der
+ * Aufrufer macht daraus 404, nicht 403: dass es die Druckansicht gibt, geht
+ * niemanden etwas an, der kein gültiges Zeichen hat.
+ */
+export function verifyRenderToken(token: string | null | undefined): RenderClaim | null {
+  if (!token) return null
+
+  const [nutzlast, unterschrift] = token.split('.')
+  if (!nutzlast || !unterschrift) return null
+
+  const erwartet = signieren(nutzlast)
+  // Zeitkonstanter Vergleich: ein Längenvergleich vorweg, weil timingSafeEqual
+  // bei ungleicher Länge wirft.
+  if (erwartet.length !== unterschrift.length) return null
+  if (!timingSafeEqual(Buffer.from(erwartet), Buffer.from(unterschrift))) return null
+
+  try {
+    const claim = JSON.parse(Buffer.from(nutzlast, 'base64url').toString('utf8')) as RenderClaim
+    if (typeof claim.expiresAt !== 'number' || claim.expiresAt < Date.now()) return null
+    if (typeof claim.userId !== 'string' || typeof claim.jobId !== 'string') return null
+    return claim
+  } catch {
+    return null
+  }
+}

web/lib/export/zip.ts

@@ -0,0 +1,101 @@
+import { createHash } from 'node:crypto'
+
+/**
+ * Ein winziger ZIP-Schreiber, nur „gespeichert" ohne Kompression.
+ *
+ * Eigener Code statt einer Abhängigkeit, weil der Inhalt eines Sammelexports
+ * PDFs und bereits neu kodierte Bilder sind — beides ist komprimiert, ein
+ * Deflate darüber bringt nichts und kostet nur CPU auf einem Heimserver. Was
+ * bleibt, ist das Behälterformat, und das sind achtzig Zeilen.
+ *
+ * Aufbau nach der ZIP-Spezifikation: je Eintrag ein lokaler Kopf mit den
+ * Daten, danach das zentrale Verzeichnis und dessen Abschluss.
+ */
+
+type Eintrag = { name: string; content: Uint8Array }
+
+/** DOS-Zeitstempel. Die Auflösung beträgt zwei Sekunden, das reicht hier. */
+function dosZeit(datum: Date): { zeit: number; datum: number } {
+  return {
+    zeit:
+      (datum.getHours() << 11) | (datum.getMinutes() << 5) | Math.floor(datum.getSeconds() / 2),
+    datum:
+      ((datum.getFullYear() - 1980) << 9) | ((datum.getMonth() + 1) << 5) | datum.getDate(),
+  }
+}
+
+function crc32(daten: Uint8Array): number {
+  // Tabelle einmal je Aufruf: bei einer Handvoll Dateien je Export ist das
+  // billiger als eine Konstante, die immer im Speicher liegt.
+  let c: number
+  const tabelle = new Int32Array(256)
+  for (let n = 0; n < 256; n++) {
+    c = n
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1
+    tabelle[n] = c
+  }
+
+  let crc = -1
+  for (const byte of daten) crc = (crc >>> 8) ^ tabelle[(crc ^ byte) & 0xff]!
+  return (crc ^ -1) >>> 0
+}
+
+export function createZip(eintraege: Eintrag[], now: Date = new Date()): Uint8Array {
+  const { zeit, datum } = dosZeit(now)
+  const teile: Buffer[] = []
+  const verzeichnis: Buffer[] = []
+  let offset = 0
+
+  for (const eintrag of eintraege) {
+    const name = Buffer.from(eintrag.name, 'utf8')
+    const inhalt = Buffer.from(eintrag.content)
+    const pruefsumme = crc32(eintrag.content)
+
+    const lokal = Buffer.alloc(30)
+    lokal.writeUInt32LE(0x04034b50, 0)
+    lokal.writeUInt16LE(20, 4) // benötigte Version
+    lokal.writeUInt16LE(0x0800, 6) // Bit 11: Name ist UTF-8
+    lokal.writeUInt16LE(0, 8) // Verfahren: gespeichert
+    lokal.writeUInt16LE(zeit, 10)
+    lokal.writeUInt16LE(datum, 12)
+    lokal.writeUInt32LE(pruefsumme, 14)
+    lokal.writeUInt32LE(inhalt.length, 18)
+    lokal.writeUInt32LE(inhalt.length, 22)
+    lokal.writeUInt16LE(name.length, 26)
+    lokal.writeUInt16LE(0, 28)
+
+    teile.push(lokal, name, inhalt)
+
+    const zentral = Buffer.alloc(46)
+    zentral.writeUInt32LE(0x02014b50, 0)
+    zentral.writeUInt16LE(20, 4)
+    zentral.writeUInt16LE(20, 6)
+    zentral.writeUInt16LE(0x0800, 8)
+    zentral.writeUInt16LE(0, 10)
+    zentral.writeUInt16LE(zeit, 12)
+    zentral.writeUInt16LE(datum, 14)
+    zentral.writeUInt32LE(pruefsumme, 16)
+    zentral.writeUInt32LE(inhalt.length, 20)
+    zentral.writeUInt32LE(inhalt.length, 24)
+    zentral.writeUInt16LE(name.length, 28)
+    zentral.writeUInt32LE(offset, 42)
+    verzeichnis.push(zentral, name)
+
+    offset += lokal.length + name.length + inhalt.length
+  }
+
+  const verzeichnisBytes = Buffer.concat(verzeichnis)
+  const abschluss = Buffer.alloc(22)
+  abschluss.writeUInt32LE(0x06054b50, 0)
+  abschluss.writeUInt16LE(eintraege.length, 8)
+  abschluss.writeUInt16LE(eintraege.length, 10)
+  abschluss.writeUInt32LE(verzeichnisBytes.length, 12)
+  abschluss.writeUInt32LE(offset, 16)
+
+  return new Uint8Array(Buffer.concat([...teile, verzeichnisBytes, abschluss]))
+}
+
+/** Für das Protokoll: worüber genau wurde ausgeleitet. */
+export function digestOf(daten: Uint8Array): string {
+  return createHash('sha256').update(daten).digest('hex')
+}