Release 0.5.10

CloudronManifest.json

@@ -3,7 +3,7 @@
 	"title": "Sendewerk",
 	"description": "Redaktionelle Planung und Durchführung von heinzlive-Sendungen.",
 	"tagline": "Vom Fundstück bis zur Livesendung",
-	"version": "0.4.0",
+	"version": "0.5.0",
 	"healthCheckPath": "/healthz",
 	"httpPort": 3000,
 	"addons": {

README.md

@@ -2,9 +2,9 @@
 
 Sendewerk ist die redaktionelle Webanwendung für den Weg vom vorbereiteten
 Inhalt bis zur moderierten und archivierten Sendung. Der aktuelle Stand umfasst
-Etappe 1 bis 4: technisches Grundgerüst, Anmeldung und Rollen, einen
+Etappe 1 bis 5: technisches Grundgerüst, Anmeldung und Rollen, einen
-persistenten Fundus sowie den vollständigen Sendungsbaukasten. Live-Steuerung
+persistenten Fundus, den Sendungsbaukasten sowie Live-Steuerung und eine
-und Präsentationsausgabe folgen in späteren Etappen.
+abgesicherte Präsentationsausgabe. Abschluss und Archivierung folgen in Etappe 6.
 
 ## Voraussetzungen
 
@@ -77,12 +77,27 @@ automatisch; ein sichtbarer Status meldet Erfolg, Fehler oder eine parallele
 Änderung. In diesem Fall muss die Seite neu geladen werden, bevor erneut
 gespeichert wird.
 
+Bereits gesendete Pieces und Pieces mit einer Einplanung in einer noch nicht
+abgeschlossenen Sendung sind standardmäßig ausgeblendet. Als gesendet gilt nur
+eine erledigte Verwendung in einer abgeschlossenen Sendung; übersprungene oder
+reservierte Inhalte gelten nicht als gesendet. Über **Auch verwendete Inhalte
+zeigen** und **Auch eingeplante Inhalte zeigen** lassen sich beide Gruppen
+unabhängig einblenden. Dann erscheinen auch Datum, Sendung und die aufklappbare
+Verwendungshistorie.
+
 Markdown ist in Einleitung, Recherche, Moderation, Überleitung und Präsentation
 möglich. Die Ausgabe wird serverseitig auf eine begrenzte Auswahl sicherer
 Elemente und Links reduziert. Bilder dürfen höchstens 5 MB groß sein und müssen
 als JPEG, PNG, WebP oder GIF erkannt werden. Sie liegen im konfigurierten
 Uploadverzeichnis und sind nur über eine angemeldete Route erreichbar.
 
+Für die Präsentation kann ein Piece alternativ genau eine seiner vorhandenen
+Quellen als Linkkarte oder Video verwenden. Linktitel, Anreißer und Bildadresse
+lassen sich manuell korrigieren. **Vorschau laden** ruft Metadaten ausdrücklich
+neu ab; manuell geänderte Felder werden dabei nicht überschrieben. Die
+**Präsentation testen**-Ansicht öffnet den aktuellen Piece-Inhalt isoliert und
+verändert weder eine Sendung noch deren laufende Ausgabe.
+
 ## Sendungen planen
 
 Unter **Sendungen** lässt sich ein neuer Stream leer, mit dem Standardablauf
@@ -92,11 +107,49 @@ eingeplanten Pieces. Die Reservebank zählt nie zur Planzeit.
 
 Der sendefertige Fundus steht neben dem Ablauf. Pieces können mehrfach
 eingeplant und je Verwendung mit eigenem Titel, eigener Dauer und eigenen
-Redaktionstexten bearbeitet werden, ohne das Original zu verändern. Abschnitte
+Redaktionstexten bearbeitet werden, ohne das Original zu verändern. Das
-und Verwendungen lassen sich per Drag-and-drop sowie gleichwertig mit sichtbaren
+Stift-Symbol öffnet dafür einen auch mobil scrollbaren Editor-Dialog. **Aus
-Schaltflächen und Auswahlfeldern verschieben. Twitch-Titel und Ankündigung sind
+Fundus aktualisieren** übernimmt auf Wunsch Titel, Dauer und Redaktionstexte des
-kopierbar. Gleichzeitige Änderungen werden über die Revision der gesamten
+aktuellen Originals; eigene Notizen, Live-Status und gemessene Zeiten bleiben
-Sendung erkannt und nicht still überschrieben.
+erhalten. Abschnitte und Verwendungen lassen sich per Drag-and-drop sowie
+gleichwertig mit sichtbaren Schaltflächen und Auswahlfeldern verschieben.
+Twitch-Titel und Ankündigung sind kopierbar. Gleichzeitige Änderungen werden
+über die Revision der gesamten Sendung erkannt und nicht still überschrieben.
+
+Die Quellspalte blendet gesendete und bereits in derselben Sendung eingeplante
+Originale zunächst aus; beide Gruppen lassen sich unabhängig wieder anzeigen.
+Eine konkrete Einplanung kann direkt hinter sich dupliziert werden. Dabei
+bleiben ihre angepassten Texte und ihre Dauer erhalten, während Live-Status und
+gemessene Zeiten neu beginnen. **Piece duplizieren** im Fundus erzeugt dagegen
+weiterhin einen eigenständigen Fundusinhalt.
+
+## Live moderieren und präsentieren
+
+Die Live-Steuerung öffnet sich aus einer geplanten Sendung. Sie zeigt
+Einleitung, Moderationsstichpunkte und Überleitung in einstellbarer
+Prompter-Schrift; die private Recherche bleibt standardmäßig geschlossen.
+Zeiten und Ablaufleiste können ausgeblendet werden. Schriftgröße, Sichtbarkeit
+und Leseposition bleiben im Browser erhalten.
+
+Start, Erledigen, Überspringen und Zurück werden persistent mit tatsächlichen
+Zeitintervallen gespeichert. Wiederholte Befehle erzeugen keine doppelte
+Zeitbuchung. Offene Pieces und die Reserve lassen sich während der Sendung
+sortieren beziehungsweise als nächster Beitrag einfügen.
+
+Das separate Präsentationsfenster unter `/heinzlive/...` verwendet einen langen,
+widerrufbaren Zufallstoken. Es ändert sich ausschließlich durch die Aktion
+**Präsentieren** und erhält nur den bei der Einplanung gespeicherten Text-, Link-
+oder Video-Snapshot. YouTube- und TikTok-Adressen werden auf validierte IDs
+reduziert und ohne Autoplay in offiziellen Player-Iframes dargestellt. Andere
+oder unvollständige Videoquellen erscheinen als Linkkarte. Recherche,
+Moderationsnotizen, eigene Notizen, Kontodaten und interne Dateipfade werden
+weder im HTML noch im JSON-Zustand ausgeliefert. Der Token ist ein
+Zugangsgeheimnis und darf nicht weitergegeben oder protokolliert werden.
+
+Metadaten und externe Vorschaubilder werden ausschließlich serverseitig mit
+DNS-, Redirect-, Zeit- und Größenlimits abgerufen. Private und lokale
+Netzwerkziele sind gesperrt. Eingebettetes HTML oder Skripte einer Quellseite
+werden nicht übernommen.
 
 ## Befehle
 
@@ -173,6 +226,7 @@ Medien und redaktionellen Inhalten werden dadurch nicht verändert.
 
 Die direkten Laufzeit- und Werkzeugabhängigkeiten verwenden MIT- oder
 Apache-2.0-Lizenzen: Svelte/SvelteKit, Vite, Vitest, ESLint und
-`better-sqlite3`, `@node-rs/argon2`, Marked, sanitize-html und file-type sind
+`better-sqlite3`, `@node-rs/argon2`, Marked, sanitize-html, file-type und
-MIT-lizenziert; Nodemailer verwendet MIT-0, TypeScript und Playwright stehen
+Metascraper sind MIT-lizenziert; Nodemailer verwendet MIT-0, TypeScript und
-unter Apache-2.0. Die Lockdatei fixiert den tatsächlich installierten Baum.
+Playwright stehen unter Apache-2.0. Die Lockdatei fixiert den tatsächlich
+installierten Baum.

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,11 @@
+# Third-party notices
+
+## Font Awesome Pro Plus 7.0.0
+
+The icon metadata in `src/lib/icons/classic-regular.ts` and the SVG sprite in
+`static/icons/classic-regular.svg` are derived from Font Awesome Pro Plus 7.0.0
+Classic Regular. Font Awesome Pro is commercial software and remains subject to
+the Font Awesome Pro commercial license:
+https://fontawesome.com/license
+
+The Sendewerk MIT license does not apply to that icon data.

docs/ACCEPTANCE.md

@@ -120,3 +120,295 @@
   ungewollten horizontalen Überlauf
 - Mobile Aufnahme des vollständigen Sendungsbaukastens visuell kontrolliert
 - `bash -n start.sh` und `git diff --check`: erfolgreich
+
+## Etappe 5
+
+| Kriterium                             | Nachweis                                                                                        | Stand                 |
+| ------------------------------------- | ----------------------------------------------------------------------------------------------- | --------------------- |
+| Lesbare Moderation                    | Prompter-Schrift, Einleitung und Überleitung im Browser; Recherche initial geschlossen          | erfüllt am 22.10.2026 |
+| Wiederherstellung                     | Live-Stand, Laufintervalle, Schriftgröße und Leseposition nach Neuladen geprüft                 | erfüllt am 22.10.2026 |
+| Keine doppelte Zeiterfassung          | Verhaltenstest wiederholt dieselbe Befehls-ID und findet genau ein Zeitintervall                | erfüllt am 22.10.2026 |
+| Explizite Präsentation                | Zweitfenster bleibt nach Start leer und ändert sich erst durch „Präsentieren“                   | erfüllt am 22.10.2026 |
+| Getrennte sichere Ausgabe             | anonymer Browserkontext prüft Text, Bild, HTML, JSON und fremde Medien ohne private Daten       | erfüllt am 22.10.2026 |
+| Reserve und Reihenfolge               | Reserve als nächstes Piece eingefügt; offene Reihenfolge und serverseitige Live-Grenze geprüft  | erfüllt am 22.10.2026 |
+| Popup- und Verbindungsfehler sichtbar | blockiertes Popup sowie unterbrochenes und wiederhergestelltes State-Polling im Browser geprüft | erfüllt am 22.10.2026 |
+| Persistente Linkvorschau              | Quellwahl, manuelle Felder, Reload, fehlendes Bild und isolierte Testansicht im Browser geprüft | erfüllt am 22.10.2026 |
+| Sichere Metadatenabrufe               | Tests sperren private IPv4-/IPv6-Ziele; Redirect-, Größen- und Zeitlimits sind implementiert    | erfüllt am 22.10.2026 |
+| Validierte Videoplayer                | YouTube-URL-Varianten, TikTok-ID, Zeitmarke und Playerwechsel automatisiert geprüft             | erfüllt am 22.10.2026 |
+| Präsentationssnapshot                 | Einplanung, Duplikation und explizite Aktualisierung aus dem Original im Servicetest geprüft    | erfüllt am 22.10.2026 |
+| Reale OBS-Browserquelle               | lokale tokenisierte Browserausgabe vorhanden; kein OBS auf der Prüfmaschine                     | offen                 |
+| Reale Anbieterwiedergabe              | automatisierte Tests fangen YouTube-/TikTok-Requests lokal ab                                   | offen                 |
+
+## Ausgeführte Prüfungen Etappe 5
+
+- `npm run lint`: erfolgreich
+- `npm run check`: 0 Fehler und 0 Warnungen
+- `npm test`: 29 Tests in 6 Dateien erfolgreich
+- `npm run build`: erfolgreich mit `@sveltejs/adapter-node`
+- `npm run test:e2e`: 14 von 14 Browsertests erfolgreich
+- Anonymer zweiter Chromium-Kontext mit Präsentationstext, Quelle, geschütztem
+  Bild und gefiltertem JSON geprüft
+- Mobile Aufnahme der Live-Steuerung bei 390 × 844 Pixeln und Desktopaufnahme
+  der heinzlive-Ausgabe visuell kontrolliert
+- Popup-Blockade sowie Verbindungsabbruch und automatische Wiederverbindung im
+  Browser geprüft
+- YouTube-/TikTok-Iframes, Playerwechsel, mobile Hochformatausgabe,
+  Linkkartenvorschau ohne Bild, isolierte Testansicht und private Datenfilterung
+  mit lokal abgefangenen Anbieterrequests geprüft
+- SSRF-Blockade einer privaten Zieladresse über die sichtbare Editorfehlermeldung
+  geprüft
+- `bash -n start.sh` und `git diff --check`: erfolgreich
+
+## Gezielte Fundus- und Einplanungsanpassung
+
+| Kriterium                                   | Nachweis                                                                                   | Stand                 |
+| ------------------------------------------- | ------------------------------------------------------------------------------------------ | --------------------- |
+| Gesendet korrekt abgeleitet                 | Servicetest schließt offene, übersprungene, Reserve- und nicht abgeschlossene Nutzung aus  | erfüllt am 22.10.2026 |
+| Historie und Fundusfilter                   | Browser prüft letztes Datum, Sendungslink, weitere Verwendungen und Sofortfilter           | erfüllt am 22.10.2026 |
+| Unabhängige Quellfilter                     | Browser kombiniert verwendet/eingeplant getrennt und erhält sie über Suchfilter            | erfüllt am 22.10.2026 |
+| Reserve und Mehrfacheinplanung              | Reserve zählt als eingeplant; bewusstes Wiedereinblenden erlaubt weitere Einplanung        | erfüllt am 22.10.2026 |
+| Rückkehr nach Entfernen                     | Browser entfernt die letzte Reserveeinplanung und bietet das Original sofort wieder an     | erfüllt am 22.10.2026 |
+| Angepasste Einplanung dupliziert            | Service und Browser prüfen Position, Texte, Notizen, Dauer und Reload                      | erfüllt am 22.10.2026 |
+| Live-Zustand des Duplikats zurückgesetzt    | Servicetest prüft `open`, neue ID und fehlende Zeitintervalle                              | erfüllt am 22.10.2026 |
+| Original unverändert                        | Piece-Anzahl und Original-ID vor und nach Einplanungsduplikation verglichen                | erfüllt am 22.10.2026 |
+| Speicherfehler nicht als Erfolg dargestellt | veraltete Revision rollt Duplikation vollständig zurück                                    | erfüllt am 22.10.2026 |
+| Globale aktive Einplanung ausgeblendet      | Browser prüft den unabhängigen Filter über mehrere nicht abgeschlossene Sendungen          | erfüllt am 22.10.2026 |
+| Snapshot ausdrücklich aktualisiert          | Service prüft neue Originaltexte und erhaltene Notizen/Intervalle; Browser löst Aktion aus | erfüllt am 22.10.2026 |
+| Fehlendes Original atomar behandelt         | Servicetest prüft Fehler und unveränderte Sendungsrevision                                 | erfüllt am 22.10.2026 |
+| Verwendungsdialog responsiv                 | Browser prüft Desktop/Mobil, Reserve, erreichbare Aktionen und sichtbare Konfliktfehler    | erfüllt am 22.10.2026 |
+
+## Ausgeführte Prüfungen Fundus und Einplanung
+
+- `npm test`: 22 Tests in 5 Dateien erfolgreich
+- `npm run lint`: erfolgreich
+- `npm run check`: 0 Fehler und 0 Warnungen
+- gezielter Playwright-Lauf: 4 von 4 Browsertests erfolgreich
+- `npm run test:e2e`: 12 von 12 Browsertests erfolgreich
+- Desktopansichten von Fundushistorie, kombinierten Sendungsfiltern und
+  Verwendungsdialog sowie mobile Quellspalte und mobiler Dialog bei 390 × 844
+  Pixeln visuell kontrolliert
+- `npm run build`: erfolgreich mit `@sveltejs/adapter-node`
+- `bash -n start.sh` und `git diff --check`: erfolgreich
+
+## Redaktionelles Piece-Arbeitsblatt
+
+| Kriterium                                | Nachweis                                                                                          | Stand                 |
+| ---------------------------------------- | ------------------------------------------------------------------------------------------------- | --------------------- |
+| Schreiben steht im Mittelpunkt           | Desktop- und Mobilprüfung zeigt Fundstück, Recherche und drei Sendungstexte im primären Lesefluss | erfüllt am 22.10.2026 |
+| Kontext bleibt vollständig erreichbar    | Quellen, Einordnung, Präsentation und Bilder auf Desktop sowie als vier mobile Werkzeuge geprüft  | erfüllt am 22.10.2026 |
+| Textfelder unabhängig bearbeitbar        | Recherche und Moderationsstichpunkte im Browser gleichzeitig geöffnet und gespeichert             | erfüllt am 22.10.2026 |
+| Bestehender Formvertrag bleibt erhalten  | Autosave, Reload, Taxonomie, Quelle, Markdown, Upload, Archiv und Duplikat im Browser durchlaufen | erfüllt am 22.10.2026 |
+| Konflikte und Speicherfehler sichtbar    | parallele Revision sowie Offline-Autosave mit erfolgreicher manueller Wiederholung geprüft        | erfüllt am 22.10.2026 |
+| Schneller Video-Einstieg ohne Einordnung | Link im Eingang aufgenommen, direkt geöffnet, beschrieben und isoliert als Video getestet         | erfüllt am 22.10.2026 |
+| Responsive Darstellung und beide Themes  | 1440 × 1000 und 390 × 844 in Light/Dark ohne horizontalen Überlauf visuell kontrolliert           | erfüllt am 22.10.2026 |
+
+## Ausgeführte Prüfungen Piece-Arbeitsblatt
+
+- `npm run lint`: erfolgreich
+- `npm run check`: 0 Fehler und 0 Warnungen
+- `npm test`: 29 Tests in 6 Dateien erfolgreich
+- `npm run build`: erfolgreich mit `@sveltejs/adapter-node`
+- gezielter Playwright-Lauf für Autosave, Offline-Fehler, Konflikt und Upload:
+  1 von 1 Browsertest erfolgreich
+- `npm run test:e2e`: 15 von 15 Browsertests erfolgreich
+- Desktop Light/Dark sowie Smartphone Light/Dark und mobiles
+  Präsentationswerkzeug visuell kontrolliert; langer Titel bricht vollständig um,
+  Werkzeugfläche ist opak und die Speicherleiste überdeckt mobil keine Eingaben
+- `bash -n start.sh` und `git diff --check`: erfolgreich
+
+## Oberflächenrelease 0.5.4
+
+| Kriterium                                  | Nachweis                                                                                       | Stand                 |
+| ------------------------------------------ | ---------------------------------------------------------------------------------------------- | --------------------- |
+| Klare Hierarchie in beiden Themes          | Eingang, Fundus, Editor, Sendungsplan und Live-Steuerung in Light/Dark visuell kontrolliert    | erfüllt am 22.10.2026 |
+| Exakte heinzlive-Darkmode-Farben           | berechnete Theme-Tokens und Screenshots der dunklen Arbeitsansichten geprüft                   | erfüllt am 22.10.2026 |
+| Responsive Darstellung ohne Seitenüberlauf | Chromium-Messung bei 1440 × 1000 und 390 × 844 Pixeln auf allen gezielt geprüften Ansichten    | erfüllt am 22.10.2026 |
+| Sendungsplan-Aktionen bleiben erreichbar   | drei sichtbare Aktionen einer Planzeile liegen waagerecht auf gleicher Höhe; Mobilbild geprüft | erfüllt am 22.10.2026 |
+| Fokus und reduzierte Bewegung              | sichtbarer Cyan-Fokusring und bestehende `prefers-reduced-motion`-Regeln im Stylesheet geprüft | erfüllt am 22.10.2026 |
+
+## Ausgeführte Prüfungen Oberflächenrelease 0.5.4
+
+- `npm run check`: 0 Fehler und 0 Warnungen
+- `npm run build`: erfolgreich mit `@sveltejs/adapter-node`
+- gezielter Chromium-Lauf für Eingang, Fundus, Piece-Editor, Sendungsplan und
+  Live-Steuerung bei 1440 × 1000 und 390 × 844 Pixeln in Light/Dark ohne
+  Konsolenfehler oder horizontalen Seitenüberlauf
+- Desktop- und Mobilaufnahmen aller genannten Ansichten visuell kontrolliert
+- vollständige Unit- und E2E-Matrix nicht erneut ausgeführt, weil dieser Release
+  ausschließlich Darstellung und redaktionelle Kurztexte verändert
+- `git diff --check`: erfolgreich
+
+## Oberflächenkorrektur 0.5.5
+
+| Kriterium                             | Nachweis                                                                                    | Stand                 |
+| ------------------------------------- | ------------------------------------------------------------------------------------------- | --------------------- |
+| Nachtblau und Glaswirkung erkennbar   | berechnete Transparenz/Unschärfe und Desktop-/Mobilaufnahmen in Darkmode geprüft            | erfüllt am 22.10.2026 |
+| Schreibfelder im Ruhezustand sichtbar | deckende Feldfarbe, feine Kontur, Innenabstand und Textcursor im Piece-Editor geprüft       | erfüllt am 22.10.2026 |
+| Goldener Tastaturfokus                | berechnete Fokusfarbe und Fokus-Schatten am Titelfeld geprüft; Cyanrahmen nicht mehr aktiv  | erfüllt am 22.10.2026 |
+| Inhaltsgerechte Feldhöhen             | kurze Einleitung ist niedriger als ausführliche Moderationsfläche; beide bleiben skalierbar | erfüllt am 22.10.2026 |
+| Lightmode und Smartphone erhalten     | fünf Arbeitsansichten bei 1440 × 1000 und 390 × 844 Pixeln ohne Seitenüberlauf geprüft      | erfüllt am 22.10.2026 |
+
+## Ausgeführte Prüfungen Oberflächenkorrektur 0.5.5
+
+- `npm run check`: 0 Fehler und 0 Warnungen
+- `npm run build`: erfolgreich mit `@sveltejs/adapter-node`
+- gezielter Chromium-Lauf in Light/Dark und Desktop/Mobil ohne Konsolenfehler
+  oder horizontalen Seitenüberlauf; Glas-, Feld- und Fokuswerte zusätzlich
+  programmatisch geprüft
+- vollständige Unit- und E2E-Matrix gemäß Auftrag nicht erneut ausgeführt
+- `git diff --check`: erfolgreich
+
+## Oberflächenkorrektur 0.5.6
+
+| Kriterium                                     | Nachweis                                                                                          | Stand                 |
+| --------------------------------------------- | ------------------------------------------------------------------------------------------------- | --------------------- |
+| Gold-/Violettlicht und Glasflächen sichtbar   | Fundus und Editor in Light/Dark auf Desktop und Mobil visuell sowie über berechnete Werte geprüft | erfüllt am 22.10.2026 |
+| Schreibflächen ruhig und eindeutig abgegrenzt | deckende Feldfarbe, Kontur und goldener Fokus im geöffneten Piece-Editor geprüft                  | erfüllt am 22.10.2026 |
+| Neuanlage und Suche unmittelbar erreichbar    | sichtbare Fundusaktionen sowie geöffnete Vorlagenauswahl auf Desktop und Mobil geprüft            | erfüllt am 22.10.2026 |
+| Zusatzfilter und Zeilenaktionen zugänglich    | native Aufklappelemente für Filter und Aktionen per Browserinteraktion geprüft                    | erfüllt am 22.10.2026 |
+| Funduszeilen per Tastatur zu öffnen           | erster Titeleintrag fokussiert, mit Eingabetaste geöffnet und Editoraufruf geprüft                | erfüllt am 22.10.2026 |
+| Lightmode und Smartphone ohne Seitenüberlauf  | Chromium-Messung bei 1440 × 1000 und 390 × 844 Pixeln in beiden Themes                            | erfüllt am 22.10.2026 |
+
+## Ausgeführte Prüfungen Oberflächenkorrektur 0.5.6
+
+- `npm run check`: 0 Fehler und 0 Warnungen
+- gezielter Chromium-Lauf für Fundus und geöffneten Piece-Editor bei
+  1440 × 1000 und 390 × 844 Pixeln in Light/Dark ohne Konsolenfehler oder
+  horizontalen Seitenüberlauf
+- Neuanlage, Zusatzfilter, Aktionsmenü, Tastaturöffnung, Glaswerte und goldener
+  Fokus automatisiert kontrolliert; alle erzeugten Desktop-/Mobilaufnahmen
+  visuell geprüft
+- Produktionsbuild sowie vollständige Unit- und E2E-Matrix gemäß Auftrag nicht
+  ausgeführt
+- `git diff --check`: erfolgreich
+
+## Materialkorrektur 0.5.7
+
+| Kriterium                                    | Nachweis                                                                                         | Stand                 |
+| -------------------------------------------- | ------------------------------------------------------------------------------------------------ | --------------------- |
+| Hintergrundlicht im Arbeitsbereich sichtbar  | Fundus und Sendungsplanung ohne Popup in Dark/Light auf Desktop und Mobil visuell geprüft        | erfüllt am 23.10.2026 |
+| Popup erhält die Lichtstimmung               | Editor mit leichtem `46%`-Backdrop und `6px` Blur gegen Ansicht ohne Popup verglichen            | erfüllt am 23.10.2026 |
+| Verschachtelte Ablaufkarten werden dunkler   | berechnete RGBA-Werte von Außenglas, Abschnitt, Piece und Aktionsgruppe kontrolliert             | erfüllt am 23.10.2026 |
+| Graue Sonderflächen entfernt                 | aktive Tabs, private Recherche, Quellen-/Materialflächen und Aktionsgruppen visuell geprüft      | erfüllt am 23.10.2026 |
+| Schreibfelder bleiben ruhig und klar         | deckende Feldfüllung, feine Kontur und unveränderter Goldfokus in beiden Editorbereichen geprüft | erfüllt am 23.10.2026 |
+| Lightmode und Smartphone ohne Seitenüberlauf | Chromium-Messung bei 1440 × 1000 und 390 × 844 Pixeln in beiden Themes                           | erfüllt am 23.10.2026 |
+
+## Ausgeführte Prüfungen Materialkorrektur 0.5.7
+
+- `npm run check`: 0 Fehler und 0 Warnungen
+- `npm run build`: erfolgreich mit `@sveltejs/adapter-node`
+- berechnete Styles vor und nach der Korrektur für App-Hintergrund, Navigation,
+  Ablauf-Panel, Abschnitte, Pieces, Aktionsgruppen, Dialog, Backdrop, Tabs,
+  Rechercheflächen und Schreibfelder kontrolliert
+- gezielter Chromium-Lauf für Sendungsplanung sowie Piece-Editor mit
+  „Sendungstext“ und „Recherche & Quellen“ bei 1440 × 1000 und 390 × 844 Pixeln
+  in Light/Dark ohne Konsolenfehler oder horizontalen Seitenüberlauf
+- Desktop-/Mobilaufnahmen mit und ohne Popup visuell verglichen
+- vollständige Funktionstests gemäß Auftrag nicht ausgeführt
+- `git diff --check`: erfolgreich
+
+## Redaktionelle Arbeitsabläufe 0.5.8
+
+| Kriterium                                  | Nachweis                                                                                         | Stand                 |
+| ------------------------------------------ | ------------------------------------------------------------------------------------------------ | --------------------- |
+| Persistente unabhängige Piece-Vorlagen     | Servicetests prüfen Snapshot, Revision, Neuanlage, Wiederverwendung und Löschen                  | erfüllt am 23.10.2026 |
+| Atomare idempotente Direktanlage           | Verhaltenstests prüfen Wiederholung derselben Befehls-ID und vollständigen Rollback              | erfüllt am 23.10.2026 |
+| Interner und öffentlicher Titel getrennt   | Service- und Browserabläufe prüfen getrennte Werte, Snapshots und Fallback                       | erfüllt am 23.10.2026 |
+| Entfernen betrifft nur konkrete Verwendung | Browser prüft Bestätigung, Rückgabe in Fundus und unverändertes Original                         | erfüllt am 23.10.2026 |
+| Beliebige Live-Verwendung auswählbar       | Verhaltenstests wählen ersten und erledigten Eintrag über stabile Usage-ID                       | erfüllt am 23.10.2026 |
+| Stabiler widerrufbarer OBS-Kanal           | Servicetests prüfen Wiederöffnung/Rotation; anonymer Browser prüft Fragmenttausch und Cookie     | erfüllt am 23.10.2026 |
+| Private Quellen und Uploads bleiben intern | HTML- und JSON-Prüfung enthält weder implizite Quellen, Uploadnamen noch interne Redaktionstexte | erfüllt am 23.10.2026 |
+| Responsive und gleichwertig bedienbar      | Chromium prüft Desktop/Mobil, Light/Dark, Drag-and-drop sowie Klick- und Tastaturalternativen    | erfüllt am 23.10.2026 |
+| Reale OBS- und Anbieterwiedergabe          | Keine OBS-Installation und keine echten Anbieteraufrufe in der lokalen Prüfumgebung              | offen                 |
+
+## Ausgeführte Prüfungen 0.5.8
+
+- `npm run lint`: nach Formatierung erfolgreich
+- `npm run check`: 0 Fehler und 0 Warnungen
+- `npm test`: 33 Tests in 6 Dateien erfolgreich
+- `npm run test:e2e`: 15 von 15 Chromium-Browsertests erfolgreich
+- Browsermatrix bei 390, 768, 960, 1280 und 1440 Pixeln einschließlich
+  Light/Dark, horizontalem Überlauf, Tastaturbedienung, Planung, Live-Steuerung
+  und anonymer Ausgabe geprüft; Screenshots wurden durch die Suite erzeugt
+- `npm run build`: erfolgreich mit `@sveltejs/adapter-node`
+- `npm run db:migrate`: Migrationen `0007_editorial_workflows.sql` und
+  `0008_durable_planning_commands.sql` erfolgreich auf der zuvor gesicherten
+  lokalen Entwicklungsdatenbank angewendet
+- `bash -n start.sh`: erfolgreich
+- reale OBS-Browserquelle und echte YouTube-/TikTok-Wiedergabe nicht ausgeführt;
+  Anbieterrequests wurden in den Browsertests lokal abgefangen
+
+## Live-Werkbank 0.5.9
+
+| Kriterium                                      | Nachweis                                                                                           | Stand                 |
+| ---------------------------------------------- | -------------------------------------------------------------------------------------------------- | --------------------- |
+| Favorit ist globale Originaleigenschaft        | Service prüft Revision/Status; Browser prüft Stern, Sortierung und weiterhin wirksamen Planfilter  | erfüllt am 23.10.2026 |
+| Werkzeugkatalog und Rechte                     | Barkeeper-Verwaltung serverseitig geschützt; Browser prüft Anlage, Formatbezug und Deaktivierung   | erfüllt am 23.10.2026 |
+| Deaktivierte Zuordnung bleibt bearbeitbar      | Browser öffnet das Piece erneut und findet Werkzeug, Arbeitslink, Notiz und Deaktivierungsstatus   | erfüllt am 23.10.2026 |
+| Relationen werden unveränderlich gesnapshottet | Service ändert Quelle, Werkzeug und Thema und sieht Änderungen erst nach expliziter Aktualisierung | erfüllt am 23.10.2026 |
+| Private Live-Materialien bleiben privat        | Live-Steuerung zeigt Snapshot-Quelle; anonymes HTML/JSON enthält den privaten Materiallink nicht   | erfüllt am 23.10.2026 |
+| Thematische Publikum-Dachzeile                 | Usage-Themen werden stabil projiziert; Chromium zeigt „Gaming“ oberhalb des Präsentationstitels    | erfüllt am 23.10.2026 |
+| Persistenter Abschnitts-Countdown              | kontrollierte Testzeit prüft eingefrorenes Soll, Reload, Piece-Wechsel und Abschluss ohne Reset    | erfüllt am 23.10.2026 |
+| Responsive Bedienung                           | komplette Browsermatrix und gezielter Werkzeugeditor bei 390 × 844 ohne horizontalen Überlauf      | erfüllt am 23.10.2026 |
+| Reale OBS- und Anbieterwiedergabe              | Keine OBS-Installation und keine echten Anbieteraufrufe in der lokalen Prüfumgebung                | offen                 |
+
+## Ausgeführte Prüfungen 0.5.9
+
+- `npm run lint`: erfolgreich
+- `npm run check`: 0 Fehler und 0 Warnungen
+- `npm test`: 37 Tests in 7 Dateien erfolgreich
+- `npm run test:e2e`: 16 von 16 Chromium-Browsertests erfolgreich
+- zusätzlicher gezielter Chromium-Lauf des Werkzeugeditors bei 390 × 844 Pixeln:
+  1 von 1 erfolgreich, ohne horizontalen Überlauf
+- Browsermatrix bei 390, 768, 960, 1280 und 1440 Pixeln einschließlich
+  Light/Dark, Planung, Live-Steuerung, anonymer Ausgabe und privater Materialien
+  erfolgreich; Screenshots wurden durch die Suite erzeugt
+- `npm run build`: erfolgreich mit `@sveltejs/adapter-node`
+- lokale Entwicklungsdatenbank vorab nach
+  `.data/backups/0.5.9-pre-migration/sendewerk.sqlite` gesichert;
+  `npm run db:migrate` hat `0009_live_workbench.sql` erfolgreich angewendet
+- `bash -n start.sh` und `git diff --check`: erfolgreich
+- reale OBS-Browserquelle und echte YouTube-/TikTok-Wiedergabe nicht ausgeführt;
+  Anbieterrequests wurden in den Browsertests lokal abgefangen
+
+## Editor-Erlebnis 0.5.10
+
+| Kriterium                                   | Nachweis                                                                                          | Stand                 |
+| ------------------------------------------- | ------------------------------------------------------------------------------------------------- | --------------------- |
+| Titel direkt und per Tastatur bearbeitbar   | Chromium prüft Vorlage, Inline-Titel, Autosave, Schließen und erneutes Öffnen                     | erfüllt am 23.10.2026 |
+| Gemeinsame Themen- und Werkzeugauswahl      | Browser prüft Auswahl, Speicherung und deaktivierte Werkzeugzuordnung; Svelte-Check ist warnfrei  | erfüllt am 23.10.2026 |
+| Themenicons lokal und persistent            | Migration und Servicetests prüfen Iconwert und Snapshot; Verwaltung nutzt lokalen Iconpicker      | erfüllt am 23.10.2026 |
+| Präsentationsbild ausdrücklich gewählt      | Browser lädt Bild hoch, aktualisiert Usage und sieht nur dieses Bild in anonymer Ausgabe          | erfüllt am 23.10.2026 |
+| Medien- und Usage-Snapshots bleiben stabil  | Servicetest entfernt Originalmedium und erhält bestehende Usage-Ausgabe                           | erfüllt am 23.10.2026 |
+| Piece-Löschen ist wiederherstellbar         | Servicetest prüft Revision, Soft Delete, Listenausblendung, Medienzugriff und Wiederherstellung   | erfüllt am 23.10.2026 |
+| Live-Verwendungen sicher entfernbar         | Servicetests erlauben nur offene, nie gelaufene, nicht aktuelle oder präsentierte Verwendungen    | erfüllt am 23.10.2026 |
+| Leere OBS-Ausgabe ist transparent           | Chromium prüft leeren Renderer vor und nach Präsentation sowie versteckten Verbindungsstatus      | erfüllt am 23.10.2026 |
+| Responsive Bedienung                        | vollständige Browsermatrix prüft 390 bis 1440 Pixel, Light/Dark und horizontalen Überlauf         | erfüllt am 23.10.2026 |
+| Reales OBS, reale Anbieter und echtes iOS   | In der lokalen Prüfumgebung nicht verfügbar                                                       | offen                 |
+| Werkzeugkatalog entspricht Themenverwaltung | Kompakte Iconzeilen und gemeinsamer Anlegen-/Bearbeitendialog wurden auf Desktop/Mobil verglichen | erfüllt am 23.10.2026 |
+| Vollständige Classic-Regular-Auswahl        | Generierung liefert 3.671 Icons; seltenes Icon wurde gesucht, gespeichert und im Piece angezeigt  | erfüllt am 23.10.2026 |
+| Formatwahl nutzt gemeinsamen Picker         | Browser ordnet Quiz im Dialog zu und erhält Format sowie Deaktivierungszustand nach Reload        | erfüllt am 23.10.2026 |
+
+## Ausgeführte Prüfungen 0.5.10
+
+- `npm run lint`: erfolgreich
+- `npm run check`: 0 Fehler und 0 Warnungen
+- `npm test`: 40 Tests in 7 Dateien erfolgreich
+- `npm run test:e2e`: 16 von 16 Chromium-Browsertests erfolgreich
+- Browsermatrix bei 390, 768, 960, 1280 und 1440 Pixeln einschließlich
+  Light/Dark, mobiler Navigation, Dialogen, Planung, Live-Steuerung, anonymer
+  Ausgabe, Medienauswahl und privater Datenfilterung erfolgreich; Screenshots
+  wurden durch die Suite erzeugt
+- `npm run build`: erfolgreich mit `@sveltejs/adapter-node`
+- lokale Entwicklungsdatenbank vorab nach
+  `.data/backups/0.5.10-pre-migration/sendewerk.sqlite` gesichert;
+  `npm run db:migrate` hat `0010_editor_experience.sql` erfolgreich angewendet
+- vor der Werkzeugmigration zusätzlich nach
+  `.data/backups/0.5.10-tool-icons-pre-migration/sendewerk.sqlite` gesichert;
+  `npm run db:migrate` hat `0011_tool_icons.sql` erfolgreich angewendet
+- Werkzeugkatalog, Anlegen-/Bearbeitendialog, geöffnete Iconauswahl und
+  Piece-Werkzeugauswahl bei 1280 × 720 und 390 × 844 Pixeln visuell direkt mit
+  der Themenverwaltung verglichen; keine horizontale Überlauffläche festgestellt
+- `bash -n start.sh`: erfolgreich
+- reale OBS-Browserquelle, echte YouTube-/TikTok-Wiedergabe und Safari auf einem
+  iOS-Gerät nicht ausgeführt; Anbieterrequests wurden lokal abgefangen

docs/ARCHITECTURE.md

@@ -33,21 +33,22 @@ spätere API dieselben Regeln verwenden.
 
 ## Gesamtdatenmodell
 
-Die ersten vier Etappen materialisieren Identität, Inhaltsverwaltung und
+Die ersten fünf Etappen materialisieren Identität, Inhaltsverwaltung,
-Sendungsplanung. Folgende Grenzen gelten für umgesetzte und spätere Bereiche.
+Sendungsplanung und Live-Durchführung. Folgende Grenzen gelten für umgesetzte
+und spätere Bereiche.
 
-| Bereich     | Geplante Entitäten und Beziehungen                                                                                                        |
+| Bereich     | Geplante Entitäten und Beziehungen                                                                                                  |
-| ----------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
+| ----------- | ----------------------------------------------------------------------------------------------------------------------------------- |
-| Identität   | `users`, Rollen, Sessions, Einladungen, Reset-Tokens und Sperren sind umgesetzt; technische Zugänge folgen später                         |
+| Identität   | `users`, Rollen, Sessions, Einladungen, Reset-Tokens und Sperren sind umgesetzt; technische Zugänge folgen später                   |
-| Taxonomie   | getrennte `section_categories`, `formats`, `topics`; Pieces und Vorschläge über Zuordnungstabellen mehrfach verknüpft                     |
+| Taxonomie   | getrennte `section_categories`, `formats`, `topics` samt optionalem Themenicon; Pieces und Vorschläge mehrfach verknüpft            |
-| Inhalt      | `pieces` mit Status, Dauer, Revision, getrennten Textbereichen, Quellen und privaten Medien; Vorlagen sind definierte Startwerte          |
+| Inhalt      | `pieces` mit Status, Soft Delete, Favorit, Revision, Texten, Quellen, Werkzeugen und privaten Medien; Vorlagen speichern Snapshots  |
-| Sendungsbau | `shows`, geordnete `show_sections`, kopierte `piece_usages`, Reservebank und Sendungsvorlagen sind umgesetzt; Original-ID bleibt Referenz |
+| Sendungsbau | `shows`, geordnete `show_sections`, `piece_usages` samt Quellen-/Werkzeug-/Themen-/Mediensnapshots, Reservebank und Vorlagen        |
-| Live        | expliziter Live-Stand, aktuelles Element, Status je Verwendung, tatsächliche Zeiten und getrennte Präsentationsausgabe                    |
+| Live        | expliziter Live-Stand, aktuelles Element, tatsächliche Piece-Zeiten, persistente Abschnittstimer und getrennte Präsentationsausgabe |
-| Historie    | unveränderliche Abschluss-Snapshots und Verwendungshistorie; Übersprungenes zählt nicht als gesendet                                      |
+| Historie    | unveränderliche Abschluss-Snapshots und Verwendungshistorie; Übersprungenes zählt nicht als gesendet                                |
-| Freigaben   | widerrufbare, gehashte Lesetokens mit Sendung, Umfang, Passwortoption und Ablaufzeit                                                      |
+| Freigaben   | widerrufbare, gehashte Lesetokens mit Sendung, Umfang, Passwortoption und Ablaufzeit                                                |
-| RSS         | Feedquellen, Abrufläufe und externe Einträge mit stabiler Herkunfts-ID sowie Status neu/übernommen/verworfen                              |
+| RSS         | Feedquellen, Abrufläufe und externe Einträge mit stabiler Herkunfts-ID sowie Status neu/übernommen/verworfen                        |
-| API/Audit   | technische Berechtigungen, Idempotenzschlüssel und Audit-Ereignisse mit Akteur, Aktion und Ziel                                           |
+| API/Audit   | technische Berechtigungen, Idempotenzschlüssel und Audit-Ereignisse mit Akteur, Aktion und Ziel                                     |
-| Betrieb     | Anwendungseinstellungen und spätere Job-Zustände, keine Geheimnisse im Klartext ohne begründete Schutzstrategie                           |
+| Betrieb     | Anwendungseinstellungen und spätere Job-Zustände, keine Geheimnisse im Klartext ohne begründete Schutzstrategie                     |
 
 ### Historien- und Kopierregel
 
@@ -63,6 +64,11 @@ oder eine explizite Abschnittsdauer. Beides wird nie addiert. Reserveelemente
 zählen erst nach dem Einplanen. Geplante und tatsächliche Dauer bleiben
 getrennt.
 
+Ein Live-Abschnittstimer entsteht ausschließlich beim tatsächlichen Eintritt in
+einen Abschnitt mit positiver expliziter Dauer. Er speichert dieses Soll als
+unveränderlichen Wert und summiert eigene Laufintervalle; Piece-Wechsel im
+selben Abschnitt erzeugen deshalb weder Reset noch doppelte Piece-Laufzeit.
+
 ## Anmeldung und Rechte
 
 Etappe 2 ergänzt lokale Konten mit den festen Rollen `barkeeper` und
@@ -96,6 +102,24 @@ erhalten ausschließlich kompakte Piece-Daten; private Recherche und vollständi
 Redaktionstexte werden nur an den angemeldeten Editor ausgeliefert. Themen und
 Abschnittskategorien sind Mehrfachzuordnungen, das Format bleibt eine einzelne
 unabhängige Zuordnung. Quellen werden gemeinsam mit einem Piece atomar ersetzt.
+`is_favorite` ist eine globale Eigenschaft des Originals und keine Nutzung oder
+Historienmarkierung. Der Werkzeugkatalog liegt getrennt von Formaten; Formate
+sind nur Eignungszuordnungen. `piece_tools` hält pro Piece den privaten
+Arbeitslink und eine Notiz, während Deaktivierung das Katalogobjekt und alle
+bestehenden Zuordnungen erhält. Ein serverseitig validiertes `icon_name` gehört
+zum Werkzeugkatalog und wird im Originaleditor angezeigt, ohne bestehende
+Usage-Snapshots nachträglich zu verändern.
+Ein Piece kann für die Präsentation Text oder genau eine vorhandene Quelle als
+Linkkarte beziehungsweise Video auswählen. Abgerufene Metadaten und Kennzeichen
+für manuell korrigierte Felder liegen am Piece; ein erneuter Abruf überschreibt
+diese Felder nicht.
+
+Piece-Vorlagen liegen als validierte JSON-Snapshots in `piece_templates`. Jeder
+Speichervorgang kopiert den vollständigen Vorlageninhalt tief und erhöht bei
+einer Aktualisierung die Revision; spätere Änderungen am Ausgangs-Piece wirken
+nicht auf die Vorlage zurück. Die leere Vorlage bleibt virtuell. Interner Titel
+und optionaler Präsentationstitel sind getrennte Felder; ohne öffentlichen Titel
+verwendet die Präsentationsprojektion den internen Titel als Fallback.
 
 Jedes Piece besitzt eine ganzzahlige Revision. Speichern, Archivieren und
 Medienänderungen verwenden ein bedingtes Update auf die erwartete Revision.
@@ -114,6 +138,15 @@ sind zufällige IDs; Originalnamen werden nie als Pfad verwendet. `/media/[id]`
 prüft die Anmeldung und liefert private Antworten mit `no-store`, `nosniff`,
 Same-Origin-Ressourcenrichtlinie und restriktiver CSP aus.
 
+Ein Piece kann genau eines seiner aktiven Medien ausdrücklich als
+Präsentationsbild auswählen. Die Auswahl liegt in `piece_presentation_media`;
+das Entfernen setzt am Medium einen Zeitstempel statt die Datei zu löschen.
+Damit bleiben bereits erzeugte `usage_media_snapshots` auflösbar, während neue
+Einplanungen und der Originaleditor nur aktive Medien berücksichtigen. Das
+Soft Delete eines Pieces setzt ebenfalls nur `deleted_at_utc`: normale Listen
+und neue Einplanungen schließen es aus, bestehende Verwendungsreferenzen und
+Snapshots bleiben unverändert erhalten.
+
 ## Sendungsbau
 
 Etappe 4 bündelt alle Planungsmutationen in `src/lib/server/shows.ts`. Eine
@@ -123,9 +156,31 @@ erhöht sie atomar. Abgeschlossene Sendungen sind bereits an dieser Grenze gegen
 weitere Bearbeitung geschützt.
 
 Beim Einplanen werden Titel, Dauer, Einleitung, Recherche, Moderation,
-Überleitung und Präsentation aus dem sendefertigen Piece kopiert. Eigene Notizen
+Überleitung und der vollständige Präsentationszustand aus dem sendefertigen
-liegen ausschließlich an der Verwendung. Die Referenz zum Original bleibt für
+Piece kopiert. Dazu gehören Modus, ausgewählte Quelladresse samt Zeitmarke,
-Historie und Nachvollziehbarkeit erhalten, wird aber nicht live gespiegelt.
+Metadaten und validierte Anbieter-ID. Zusätzlich speichern eigene geordnete
+Tabellen alle Quellen, Werkzeugnamen samt Start-/Arbeitslink und Notiz, die
+Themennamen samt Icon sowie das ausdrücklich ausgewählte Präsentationsmedium.
+Eigene Notizen liegen ausschließlich an
+der Verwendung. Die Referenz zum Original bleibt für Historie und
+Nachvollziehbarkeit erhalten, wird aber nicht live gespiegelt. Eine explizite
+Aktualisierung aus dem Fundus ersetzt Titel, Dauer, alle fünf Redaktionstexte
+und den Präsentationszustand atomar aus dem referenzierten Original. Eigene
+Notizen, Status und vorhandene Live-Intervalle werden dabei nicht verändert;
+fehlt das Original oder ist die Sendungsrevision veraltet, wird die gesamte
+Mutation verworfen.
+Eine Einplanung zu duplizieren kopiert genau diesen Snapshot mit derselben
+Original-ID direkt hinter das Ausgangselement. Die neue Verwendung erhält den
+Status `open`, eine neue ID und damit weder Live-Referenzen noch Zeitintervalle.
+
+Die Verwendungshistorie wird nicht separat gepflegt. Sie wird über die
+Original-ID aus Verwendungen mit Status `done` in abgeschlossenen Sendungen
+abgeleitet; Reservebank und alle anderen Verwendungs- oder Sendungsstatus sind
+ausgeschlossen. Über dieselbe Original-ID wird unabhängig davon ermittelt, ob
+mindestens eine Verwendung in einer noch nicht abgeschlossenen Sendung liegt.
+Der allgemeine Fundus blendet diesen globalen Kontext standardmäßig aus. Die
+Quellspalte einer Sendung betrachtet für ihren separaten Einplanungsfilter nur
+die aktuelle Sendung einschließlich Reservebank.
 
 Jede Sendung besitzt intern genau einen ausgeblendeten Reserveabschnitt. Dadurch
 verwenden Plan und Reserve dieselbe geprüfte Verwendungslogik, während die
@@ -137,18 +192,84 @@ Sendungsvorlagen und ihre Abschnitte sind eigene Tabellen. Beim Anlegen werden
 die Abschnitte mit neuen IDs kopiert; spätere Änderungen an der Sendung können
 die Vorlage deshalb nicht verändern.
 
+Die Direktanlage aus einer Sendung erzeugt Piece und Verwendung innerhalb einer
+verschachtelbaren SQLite-Transaktion. `planning_commands` speichert die
+Befehls-ID und das Ergebnis, sodass ein wiederholter Request dieselben IDs
+zurückgibt und weder ein zweites Piece noch eine zweite Einplanung erzeugt.
+
 Die Editorformulare bleiben progressive SvelteKit-Form-Actions, werden im
-Browser aber mit `use:enhance` gesendet. Dadurch bleibt das Dokument bei
+Browser aber mit `use:enhance` gesendet. Der Verwendungseditor liegt in einem
-Planungsmutationen bestehen; nur die serverseitigen Seitendaten werden
+nativen Dialog, den ein beschrifteter Icon-Button öffnet. Dadurch bleibt das
-aktualisiert. Ladeanzeige und FLIP-Animation liegen am betroffenen Abschnitt
+Dokument bei Planungsmutationen bestehen; nur die serverseitigen Seitendaten
-oder an der betroffenen Verwendung. Eindeutige Drag-Griffe übertragen entweder
+werden aktualisiert. Ladeanzeige und FLIP-Animation liegen am betroffenen
-eine Quellenkopie, einen Abschnitt oder eine Verwendung auf dieselben
+Abschnitt oder an der betroffenen Verwendung. Eindeutige Drag-Griffe übertragen
+entweder eine Quellenkopie, einen Abschnitt oder eine Verwendung auf dieselben
 serverseitig geprüften Actions wie die alternativen Schaltflächen. Während des
 Ziehens bleibt das Original transparent an seinem Ausgangsort; eine flüchtige
 Vorschau in der Liste belegt bereits die anhand der Zeigerposition berechnete
 Zielhöhe und verdrängt dadurch die benachbarten Elemente. Persistiert wird erst
 beim Loslassen.
 
+Die Ausschlussfilter für gesendete und bereits eingeplante Pieces arbeiten
+clientseitig auf der serverseitig berechneten Kontextmenge. Ihr Zustand wird
+ohne Navigation in die URL übernommen und bei nachfolgenden Suchfiltern
+mitgesendet. Planmutationen invalidieren anschließend die Seitendaten, sodass
+das Entfernen der letzten Einplanung ein Original unmittelbar wieder anbietet.
+
+## Live-Modus und Präsentationsgrenze
+
+`src/lib/server/live.ts` ist die Transaktionsgrenze der Live-Durchführung. Der
+Live-Stand besitzt eine eigene Revision. Jeder steuernde Befehl trägt zusätzlich
+eine vom Browser erzeugte Befehls-ID; `(show_id, command_id)` ist eindeutig und
+liefert bei Wiederholung das bereits gespeicherte Ergebnis. Tatsächliche Zeiten
+liegen als mehrere Start-/Endintervalle je Verwendung vor. Damit bleiben
+Zurückgehen, Wiederaufnahme und bereits abgeschlossene Laufzeit getrennt von der
+geplanten Dauer nachvollziehbar.
+
+Die interne Route `/live` benötigt weiterhin eine aktive Sitzung und darf
+Recherche, Moderation und eigene Arbeitsdaten lesen. Die separate Ausgabe nutzt
+den stabilen Kanal `/heinzlive/default` in einem reduzierten Layout ohne
+Navigation oder Nutzerdaten. Der geheime 256-Bit-Schlüssel steht nur im
+URL-Fragment und wird per POST gegen ein `HttpOnly`-, `SameSite=Strict`-Cookie
+getauscht. SQLite speichert seinen SHA-256-Hash für die Zugangsprüfung sowie den
+rohen Schlüssel, weil die angemeldete Steuerung dieselbe stabile OBS-Adresse
+erneut ausgeben können muss. Datenbank und Sicherungen sind deshalb Teil der
+Geheimnisgrenze. Eine Rotation widerruft den bisherigen Schlüssel, normales
+erneutes Öffnen behält ihn bei.
+Page, Polling-JSON und Proxyrouten leiten ihre Daten aus einer eigenen
+Positivliste ab. Private Quellen-/Werkzeug-Snapshots, Arbeitslinks, Notizen und
+Uploads werden nicht veröffentlicht; nur Themennamen sowie die ausdrücklich
+gewählte Link- oder Videoquelle und deren erlaubte Vorschau-URL können die
+Grenze passieren.
+Normale Auswahl, Fortschaltung oder Wiederaufnahme verändern den
+Präsentationsstand nicht. Die öffentliche Projektion liest ausschließlich den
+gespeicherten Verwendungssnapshot; spätere Änderungen am Original erscheinen
+erst nach einer ausdrücklichen Snapshot-Aktualisierung.
+
+Linkmetadaten werden nur auf ausdrückliche Aktion durch
+`src/lib/server/presentation.ts` geladen. Jeder HTTP(S)-Abruf löst den Zielhost
+serverseitig auf, sperrt lokale und private IPv4-/IPv6-Ziele und bindet den
+Request an die geprüfte Adresse. Dieselbe Prüfung gilt nach höchstens drei
+Redirects. Zeit- und Größenlimits begrenzen HTML, Anbieter-Metadaten und Bilder.
+Externe Vorschaubilder gelangen nur über token- beziehungsweise
+sitzungsgebundene Proxyrouten in die Ausgabe; fremdes HTML und fremde Skripte
+werden nie übernommen.
+
+Videoquellen werden aus der gespeicherten URL erneut auf eine streng validierte
+YouTube- oder TikTok-ID reduziert. Der Browser erhält nur daraus erzeugte
+offizielle Embed-URLs, startet sie nicht automatisch und ersetzt das Iframe bei
+jedem Inhaltswechsel. YouTube erhält die Startsekunde als Embed-Parameter;
+TikTok wird nach dessen Bereitschaft über die offizielle Player-`postMessage`-
+Schnittstelle positioniert. Nicht unterstützte oder unvollständige Videoquellen
+fallen auf eine normale Linkkarte zurück. Eine authentifizierte Testansicht
+verwendet denselben Renderer, schreibt aber keinen Live-Zustand.
+
+Die Ausgabe synchronisiert ihren kleinen öffentlichen Zustand per
+`no-store`-Polling. Der letzte gültige Inhalt bleibt bei einem Verbindungsfehler
+sichtbar; die Oberfläche kennzeichnet den Abbruch und versucht die Verbindung
+mit verlangsamtem Intervall erneut. Private Live-Daten werden nicht Teil dieses
+Zustandsobjekts.
+
 ## Oberflächenstruktur
 
 Die Hauptnavigation umfasst Eingang, Fundus, Sendungen, Archiv und Verwaltung.
@@ -158,17 +279,32 @@ die untere Hauptnavigation die Seitenleiste vollständig. Auf breiten Ansichten
 stehen Fundus und Ablauf nebeneinander. Bis einschließlich `72rem` werden sie
 über eine gut erreichbare Umschaltung einzeln gezeigt, damit auch schmale
 Desktopfenster ohne horizontalen Überlauf bedienbar bleiben.
-Der Live-Modus ist eine eigene, fokussierte Ansicht; die spätere
+Der Live-Modus ist eine eigene, fokussierte Arbeitsansicht. Die
-Präsentationsausgabe erhält eine separate, strikt reduzierte Datenansicht.
+Präsentationsausgabe verwendet eine separate, strikt reduzierte Datenansicht
+ohne interne Anwendungsnavigation.
 
-Fundus und Sendungsbau sind produktive Arbeitsansichten. Der Live-Modus bleibt
+Icons werden aus dem lokalen Font-Awesome-Classic-Regular-Sprite unter
-bis Etappe 5 eine sichtbare Gestaltungsvorschau, kann aber bereits gezielt die
+`static/icons` gerendert. Die Verwaltung lädt zusätzlich die durchsuchbaren
-gewählte Sendung und deren kopierte Texte lesen.
+Metadaten aller 3.671 Icons, zeigt je Suchergebnis aber höchstens 120 Einträge
+gleichzeitig. Allgemeine Seiten wie Login oder Navigation laden den Katalog
+nicht in ihren Client-Chunk.
 
-## Sicherheitsgrenzen ab den Folgeetappen
+Der eigenständige Piece-Editor ordnet denselben Formvertrag als redaktionelles
+Arbeitsblatt an. Titel, Fundstück, private Recherche sowie Einleitung,
+Moderationsstichpunkte und Überleitung bilden die primäre Schreibfläche.
+Quellen, Einordnung, Präsentation und eine Bildzusammenfassung liegen auf breiten
+Ansichten in einer kontextuellen Seitenleiste; auf kleinen Ansichten öffnen
+dieselben DOM-Formfelder als fokussierbare Werkzeugflächen und werden dabei nicht
+neu erzeugt oder ausgehängt. `EditorialMarkdownField` hält Lese- und
+Bearbeitungszustand je Textfeld lokal, während alle Werte weiterhin gemeinsam
+über die bestehende `save`-Action und Piece-Revision gespeichert werden. Die
+separate Bild-Action und alle Präsentationsactions bleiben eigene serverseitige
+Mutationen.
+
+## Sicherheitsgrenzen
 
 Authentifizierung und Autorisierung werden seit Etappe 2 serverseitig an jeder
 betroffenen Route und Action geprüft. Markdown und fremdes HTML werden vor
-Ausgabe bereinigt. Uploadzugriff folgt denselben Rechten. Spätere
+Ausgabe bereinigt. Uploadzugriff folgt denselben Rechten. Netzwerkabrufe für
-Netzwerkabrufe erhalten Schutz gegen interne Ziele, Größen-/Zeitlimits und
+Präsentationsmetadaten und Vorschaubilder schützen interne Ziele auch nach
-kontrollierte Redirects.
+DNS-Auflösung und Redirects und besitzen Größen-, Zeit- und Redirectlimits.

docs/DECISIONS.md

@@ -1,6 +1,6 @@
 # Entscheidungen
 
-Stand der Quellenprüfung: 21. Oktober 2026. Verwendet wurden offizielle
+Stand der Quellenprüfung: 22. Oktober 2026. Verwendet wurden offizielle
 Dokumentationen und die npm-Registry für konkrete Paket-Metadaten.
 
 ## D-001: SvelteKit 3 und Node-Unterstützung
@@ -202,3 +202,161 @@ Quellen:
 
 - <https://www.w3.org/WAI/WCAG22/Understanding/dragging-movements>
 - <https://svelte.dev/docs/kit/form-actions>
+
+## D-016: Live-Befehle idempotent, tatsächliche Zeiten als Intervalle
+
+Die Live-Steuerung verwendet eine eigene Revision und zusätzlich eine pro
+Bedienaktion erzeugte Befehls-ID. Die Datenbank akzeptiert jede Kombination aus
+Sendung und Befehls-ID nur einmal. Ein nach Verbindungsabbruch wiederholter
+Befehl liefert dieselbe Ergebnisrevision und erzeugt weder einen zweiten
+Statuswechsel noch ein zweites Zeitintervall. Laufzeit wird nicht als einzelner
+überschreibbarer Wert, sondern als Summe abgeschlossener und höchstens eines
+aktiven Intervalls ermittelt. Dadurch bleiben Zurückgehen und Wiederaufnahme
+korrekt.
+
+## D-017: Präsentationsausgabe als Positivliste mit gehashtem Zugang
+
+Die heinzlive-Ausgabe ist kein eingeschränkter Aufruf der internen Live-Ansicht,
+sondern eine eigene Datenprojektion. Zulässig sind ausschließlich ausdrücklich
+präsentierter Titel und Präsentationstext, öffentliche Quellen sowie zugehörige
+Bilder und Alternativtexte. Recherche, Einleitung, Moderation, eigene Notizen,
+Ablauf, Nutzer und interne Dateinamen werden nicht in HTML oder JSON übernommen.
+Ein zufälliger 256-Bit-Token steht in der URL, während SQLite nur seinen
+SHA-256-Hash speichert. Medienzugriff prüft Token, aktuelle Präsentation und
+Bildzuordnung gemeinsam. Synchronisierung erfolgt über kleines `no-store`-
+Polling statt über eine dauerhaft offene Serververbindung.
+
+## D-018: Verwendung aus bestehenden Sendungsdaten ableiten
+
+„Gesendet“ ist kein Zustand am Fundus-Piece. Die Anzeige wird ausschließlich
+aus der vorhandenen Original-ID, einer erledigten Verwendung außerhalb der
+Reservebank und dem Status `completed` ihrer Sendung abgeleitet. Dadurch können
+Einplanung, Reserve und Überspringen ein Original nicht versehentlich als
+gesendet markieren, und mehrere tatsächliche Verwendungen bleiben als Historie
+sichtbar.
+
+Eine Duplikation im Sendungsablauf kopiert den konkreten Verwendungssnapshot und
+nicht das Original-Piece. Die neue ID, der Status `open` und fehlende
+Live-Intervalle trennen sie von der bisherigen Durchführung. Der allgemeine
+Verwendungseditor darf den Live-Status nicht mehr aus Formulardaten schreiben;
+Statuswechsel bleiben der Live-Geschäftslogik vorbehalten.
+
+Eine bestehende Einplanung wird nicht automatisch mit späteren Änderungen am
+Original synchronisiert. Die ausdrücklich ausgelöste Aktion **Aus Fundus
+aktualisieren** überschreibt nur Titel, Dauer und Redaktionstexte. Eigene
+Notizen, Status und Messintervalle bleiben erhalten. Alle Zuordnungen und Filter
+verwenden ausschließlich `original_piece_id`, niemals veränderliche Titel. Im
+allgemeinen Fundus gilt „eingeplant“ global für jede nicht abgeschlossene
+Sendung; im Sendungsbau gilt es lokal für die aktuelle Sendung samt Reserve.
+
+## D-019: Lokale Linkmetadaten und streng abgeleitete Video-Embeds
+
+Sendewerk verwendet Metascraper ausschließlich serverseitig, um Titel,
+Beschreibung, Bild und Herausgeber einer ausdrücklich gewählten vorhandenen
+Quelle zu ermitteln. Die Ergebnisse werden gespeichert und nicht bei jedem
+Seitenaufruf neu geladen. Manuell korrigierte Felder haben Vorrang. Ein eigener
+HTTP(S)-Client prüft Protokoll, Port, DNS-Ergebnisse und jedes Redirectziel,
+bindet den Request an die geprüfte öffentliche Adresse und begrenzt Redirects,
+Laufzeit und Antwortgröße. Damit ist weder ein externer Vorschaudienst noch die
+Übernahme fremden HTMLs erforderlich.
+
+Player werden nur für streng erkannte YouTube- und TikTok-URLs erzeugt. Aus der
+validierten Anbieter-ID baut Sendewerk die offiziellen Embed-Adressen selbst;
+gespeichertes oder fremd geliefertes Embed-HTML wird nicht verwendet. YouTube
+nutzt die datenschutzreduzierte `youtube-nocookie.com`-Adresse und den
+`start`-Parameter. TikTok erhält eine Startposition nach `onPlayerReady` über
+die dokumentierte Player-`postMessage`-API. Autoplay bleibt ausgeschaltet, und
+ein Inhaltswechsel ersetzt das Iframe vollständig.
+
+Quellen:
+
+- <https://github.com/microlinkhq/metascraper>
+- <https://developers.google.com/youtube/player_parameters>
+- <https://developers.google.com/youtube/terms/required-minimum-functionality>
+- <https://developers.tiktok.com/doc/embed-player>
+- <https://developers.tiktok.com/doc/embed-videos>
+- <https://owasp.org/www-community/attacks/Server_Side_Request_Forgery>
+
+## D-020: Stabile Ausgabekanal-Adresse mit Fragment-Schlüssel
+
+OBS soll eine dauerhaft konfigurierte Adresse verwenden können, ohne dass ein
+Zugangsschlüssel in HTTP-Requests, Serverlogs oder Referer-Headern erscheint.
+Darum bleibt die Kanaladresse `/heinzlive/default` stabil und trägt den
+zufälligen Schlüssel ausschließlich als URL-Fragment. Ein kleiner Browser-POST
+tauscht ihn gegen ein `HttpOnly`-, `SameSite=Strict`-Cookie; danach greifen
+Seite, Polling und erlaubte Proxys nur mit diesem Cookie zu. Für die Prüfung
+liegt ein SHA-256-Hash vor. Der rohe Schlüssel muss zusätzlich in SQLite
+gespeichert werden, weil die angemeldete Steuerung dieselbe stabile OBS-Adresse
+nach einem Neustart erneut ausgeben können muss. Damit sind Datenbank und
+Sicherungen bewusst Teil der Geheimnisgrenze. Wiederholtes Öffnen behält den
+Schlüssel, eine ausdrückliche Rotation widerruft ihn sofort.
+
+Die öffentliche Projektion folgt einer engeren Positivliste als der interne
+Piece-Snapshot. Weder private Uploads noch alle Piece-Quellen werden implizit
+veröffentlicht. Passieren dürfen nur öffentlicher Text, Präsentationstitel sowie
+die ausdrücklich gewählte und erneut validierte Link- oder Videoquelle mit
+erlaubten Vorschaufeldern.
+
+## D-021: Vorlagen-Snapshots und idempotente Direktanlage
+
+Persistente Piece-Vorlagen speichern validierte, tief kopierte JSON-Snapshots
+mit eigener Revision. Damit bleiben sie unabhängig von späteren Änderungen am
+Ausgangs-Piece, ohne für jedes optionale Piece-Feld eine zweite Tabellenstruktur
+zu benötigen. Die virtuelle leere Vorlage wird nicht persistiert.
+
+Eine Direktanlage im Sendungsplan ist ein einzelner fachlicher Befehl. Piece,
+Verwendung und Sendungsrevision werden in derselben SQLite-Transaktion
+geschrieben. `planning_commands` macht die Befehls-ID eindeutig und speichert
+das Ergebnis, damit Wiederholungen nach Verbindungsabbrüchen keine Dubletten
+erzeugen. Interner und öffentlicher Titel werden getrennt gespeichert und beim
+Einplanen getrennt in den Verwendungssnapshot kopiert.
+
+## D-022: Werkzeuge und Live-Abschnittszeit als eigene Snapshot-Grenzen
+
+Favoriten bleiben ein boolesches Merkmal des Fundus-Originals. Sie ändern weder
+Revision, Status noch Verwendungshistorie und werden nicht pro Konto
+dupliziert. Der Werkzeugkatalog ist eine eigene Entität: Formatbeziehungen
+beschreiben nur die Eignung, während Piece-Zuordnungen den privaten Arbeitslink
+und die Notiz tragen. Katalogeinträge werden deaktiviert statt gelöscht, damit
+bestehende Piece- und Sendungsbezüge lesbar bleiben.
+
+Beim Einplanen kopieren eigene Relationstabellen alle Quellen, Werkzeuge und
+sortierten Themennamen an die Verwendung. Damit können Katalognamen, URLs,
+Themen und Originalzuordnungen später geändert werden, ohne eine vorbereitete
+Sendung still umzuschreiben. Nur die bewusste Aktion **Aus Fundus aktualisieren**
+ersetzt diese Snapshots. Die öffentliche Positivliste darf daraus ausschließlich
+die Themen-Dachzeile übernehmen; private Materiallinks und Werkzeugdaten bleiben
+auf der authentifizierten Live-Route.
+
+Der Abschnitts-Countdown verwendet von den Piece-Laufintervallen getrennte
+`live_section_timers` und `live_section_timer_runs`. Beim ersten tatsächlichen
+Eintritt wird eine positive explizite Abschnittsdauer eingefroren. Weitere
+Pieces desselben Abschnitts nutzen denselben Timer; Abschnittswechsel schließen
+ihn. So bleiben Reload und Wiederaufnahme persistent, ohne die vorhandene
+Piece-Zeiterfassung doppelt zu zählen.
+
+## D-023: Ausdrückliche Medienauswahl und wiederherstellbares Entfernen
+
+Ein privater Piece-Upload wird nicht allein durch seine Existenz öffentlich.
+Das Original verweist ausdrücklich auf höchstens ein aktives
+Präsentationsmedium. Beim Einplanen oder bewussten Aktualisieren wird diese
+Auswahl mit Medium-ID und Alternativtext an die Verwendung kopiert. Die
+öffentliche Route akzeptiert nur das Medium des aktuell präsentierten
+Usage-Snapshots; Originalname, interner Speicherpfad und andere Uploads bleiben
+außerhalb der Projektion.
+
+Medien und Pieces werden nicht physisch gelöscht, solange bestehende
+Sendungsfassungen auf ihre unveränderlichen Snapshots angewiesen sein können.
+Zeitstempel blenden sie aus aktuellen Arbeitslisten und neuen Einplanungen aus,
+erhalten aber Referenzen und ermöglichen die Wiederherstellung von Pieces. Eine
+Verwendung oder ein Abschnitt darf dagegen nur entfernt werden, solange keine
+betroffene Verwendung jemals live gelaufen ist und weder aktuell noch
+präsentiert wird.
+
+Der lokale Iconkatalog enthält die vollständige Classic-Regular-Familie mit
+3.671 Icons. Ein generierter Metadatenkatalog ermöglicht Suche und serverseitige
+Validierung, während ein statischer SVG-Sprite über den gemeinsamen
+`currentColor`-Renderer dargestellt wird. So lädt die Navigation nicht sämtliche
+Pfaddaten in ihren JavaScript-Chunk. Es gibt weder einen externen Laufzeitabruf
+noch eine Laufzeitabhängigkeit vom benachbarten Quellverzeichnis; Herkunft und
+Lizenz stehen in `THIRD_PARTY_NOTICES.md`.

docs/RELEASE_NOTES.md

@@ -0,0 +1,55 @@
+# Release Notes
+
+## 0.5.10 - Editor-Erlebnis
+
+### Redaktion und Verwaltung
+
+- Titel von Fundus- und Sendungsfassungen lassen sich direkt und per Tastatur
+  bearbeiten.
+- Themen und Werkzeuge verwenden gemeinsame kompakte Auswahlflächen.
+- Der Werkzeugkatalog entspricht der Themenverwaltung: kompakte Glasfläche,
+  Icon, Name, Status und Bearbeitungsaktion statt dauerhaft offener Formulare.
+- Anlegen und Bearbeiten eines Werkzeugs verwenden denselben responsiven Dialog
+  für Name, Start-URL, Beschreibung, Icon, passende Formate und Aktivstatus.
+- Die Formatzuordnung nutzt dieselbe durchsuchbare Mehrfachauswahl wie andere
+  Zuordnungen. Deaktivierte Werkzeuge und bestehende Piece-Zuordnungen bleiben
+  erhalten.
+- Alle 3.671 Icons aus Font Awesome Pro Plus 7.0.0 Classic Regular stehen lokal
+  und durchsuchbar zur Verfügung. Ein lokaler SVG-Sprite hält den allgemeinen
+  Anwendungs-Chunk klein; es gibt keine externe Laufzeitabhängigkeit.
+
+### Pieces und Präsentation
+
+- Präsentationsbilder werden ausdrücklich aus aktiven Piece-Medien ausgewählt
+  und unveränderlich an Sendungsfassungen kopiert.
+- Entfernte Medien bleiben für bestehende Sendungsfassungen verfügbar, werden
+  aber nicht mehr für neue Einplanungen angeboten.
+- Pieces können wiederherstellbar gelöscht werden. Offene, nie live gelaufene
+  Verwendungen und Abschnitte lassen sich unter geschützten Bedingungen
+  entfernen.
+- Fundus, Eingang, Archiv, Vorlagen und Sendungsansichten sind kompakter und
+  bleiben per Klick, Touch und Tastatur bedienbar.
+
+### Live-Ausgabe
+
+- Eine leere heinzlive-Ausgabe ist vollständig transparent und zeigt weder
+  Renderer noch Verbindungsstatus.
+- Eine aktive Präsentation lässt sich unabhängig vom aktuell laufenden Piece
+  leeren.
+
+### Datenbank und Kompatibilität
+
+- `0010_editor_experience.sql` ergänzt Themenicons, Medien-Snapshots und Soft
+  Delete.
+- `0011_tool_icons.sql` ergänzt persistente Werkzeugicons mit einem sicheren
+  Standardwert. Werkzeug-IDs, Formatbeziehungen, Piece-Zuordnungen und
+  Deaktivierungszustände bleiben erhalten.
+
+### Prüfung
+
+- 40 Unit- und Verhaltenstests sowie 16 Chromium-E2E-Abläufe erfolgreich.
+- Werkzeugverwaltung, Iconauswahl und Piece-Werkzeugauswahl wurden zusätzlich
+  bei 1280 × 720 und 390 × 844 Pixeln visuell mit der Themenverwaltung
+  verglichen.
+- Reales OBS, echte YouTube-/TikTok-Wiedergabe und Safari auf einem iOS-Gerät
+  standen nicht zur Verfügung.

docs/STATUS.md

@@ -2,9 +2,169 @@
 
 ## Aktueller Umfang
 
-Etappe 1 bis Etappe 4 sind abgeschlossen. Architektur, Gesamtdatenmodell,
+Etappe 1 bis Etappe 5 sind abgeschlossen. Architektur, Gesamtdatenmodell,
-Anmeldung, Rollen, persistente Inhaltsbearbeitung, Sendungsplanung und lokaler
+Anmeldung, Rollen, persistente Inhaltsbearbeitung, Sendungsplanung,
-Betriebsweg sind dokumentiert. Etappe 5 wurde nicht begonnen.
+Live-Steuerung, Präsentationsausgabe und lokaler Betriebsweg sind dokumentiert.
+Etappe 6 wurde nicht begonnen.
+
+## Editor-Erlebnis 0.5.10
+
+- direkte, tastaturbedienbare Titelbearbeitung in Fundus- und Sendungsfassungen
+  sowie gemeinsame kompakte Auswahlflächen für Themen und Werkzeuge
+- vollständiger lokaler Classic-Regular-Katalog mit 3.671 Icons für Navigation,
+  Aktionen sowie frei wählbare Themen- und Werkzeugicons; durchsuchbare
+  Metadaten und SVG-Sprite vermeiden externe Laufzeitabhängigkeiten
+- kompakter Werkzeugkatalog nach dem Muster der Themenverwaltung; Anlegen und
+  Bearbeiten teilen einen responsiven Dialog mit gestalteter Icon- und
+  Formatauswahl, bestehende Zuordnungen und Deaktivierung bleiben erhalten
+- Präsentationsbilder werden bewusst aus aktiven Piece-Medien ausgewählt und als
+  unveränderlicher Usage-Snapshot eingeplant; private Bilder werden dadurch
+  weder implizit noch nach späterer Originaländerung öffentlich
+- entfernte Medien bleiben für bestehende Sendungsfassungen erhalten, während
+  neue Einplanungen nur aktive Medien übernehmen
+- wiederherstellbares Soft Delete für Pieces sowie geschütztes Entfernen offener,
+  nie live gelaufener Verwendungen und Abschnitte
+- kompaktere Fundus-, Eingangs-, Archiv-, Vorlagen- und Sendungsansichten mit
+  mobilen, touch- und tastaturbedienbaren Alternativen
+- transparente leere heinzlive-Ausgabe ohne sichtbaren Renderer oder
+  Verbindungsstatus; die Steuerung kann eine aktive Präsentation unabhängig vom
+  aktuellen Piece leeren
+
+Etappe 6 bleibt unverändert unbegonnen. Die lokale Prüfmatrix umfasst 40
+Verhaltenstests und 16 Chromium-Abläufe. Reales OBS, echte
+YouTube-/TikTok-Wiedergabe sowie Safari auf einem iOS-Gerät bleiben mangels
+verfügbarer Umgebung offen.
+
+## Live-Werkbank 0.5.9
+
+- globale Favoriten am Fundus-Original mit stabiler Vorsortierung; verwendete
+  Favoriten bleiben sichtbar, geplante Favoriten respektieren weiterhin den
+  Einplanungsfilter
+- Barkeeper-Werkzeugkatalog mit Start-URL, Beschreibung, passenden Formaten und
+  verlustfreier Deaktivierung; Arbeitslink und Notiz bleiben für die gesamte
+  Thekencrew im gemeinsamen Piece- und Verwendungseditor bearbeitbar
+- vollständige, voneinander unabhängige Usage-Snapshots für Quellen, Werkzeuge
+  und alphabetisch stabilisierte Themen; spätere Original- oder
+  Katalogänderungen wirken erst nach bewusster Aktualisierung aus dem Fundus
+- kompakte private Materialliste in der Live-Steuerung mit Arbeitslink vor
+  Start-URL und verständlichem Zustand ohne URL
+- responsive Themen-Dachzeile in der Publikumsausgabe; ohne Thema bleibt sie
+  vollständig aus, während Präsentations- und interner Titel getrennt bleiben
+- persistenter Abschnitts-Countdown für positive explizite Abschnittsdauern mit
+  eingefrorenem Soll, sekündlicher Anzeige, Goldwarnung ab zwei Minuten und
+  roter Überziehung ohne Ton, Blinken oder automatische Weiterschaltung
+
+Etappe 6 bleibt unverändert unbegonnen. Reales OBS und echte
+YouTube-/TikTok-Wiedergabe bleiben mangels verfügbarer Umgebung offen.
+
+Die lokale Prüfmatrix umfasst 37 Verhaltenstests und 16 Chromium-Abläufe.
+Desktop, Smartphone, Light/Dark, Favoritenfilter, Werkzeug-Deaktivierung,
+Snapshot-Stabilität, private Live-Materialien, öffentliche Themenprojektion und
+persistente Abschnittszeit wurden geprüft.
+
+## Redaktionelle Arbeitsabläufe 0.5.8
+
+- persistente Piece-Vorlagen als unabhängige, revisionierte Snapshots; eigene
+  Vorlagen lassen sich aus Fundus-Pieces speichern, erneut verwenden und löschen
+- atomare, idempotente Piece-Neuanlage direkt in einer Sendung einschließlich
+  Einplanung; fehlgeschlagene Schritte hinterlassen weder Piece noch Verwendung
+- getrennte interne und öffentliche Titel an Piece und Verwendung; ein leerer
+  Präsentationstitel fällt kontrolliert auf den internen Titel zurück
+- präzises Entfernen einzelner Verwendungen mit Bestätigung sowie zusätzlicher
+  Drag-and-drop-Rückgabe in den Fundusbereich
+- Auswahl jedes konkreten Ablauf-Pieces in der Live-Steuerung, einschließlich
+  erstem und bereits erledigtem Eintrag
+- stabiler OBS-Ausgabekanal `/heinzlive/default` mit geheimem URL-Fragment,
+  HttpOnly-Cookie-Austausch und ausdrücklicher Schlüsselrotation
+- öffentliche Ausgabe als Positivliste: implizite Piece-Quellen und private
+  Uploads werden nicht mehr veröffentlicht; nur ausdrücklich gewählte
+  Link-/Videoquellen und deren erlaubte Vorschau bleiben sichtbar
+
+Die vollständige lokale Prüfmatrix umfasst 33 Verhaltenstests und 15
+Chromium-Abläufe. Desktop, Mobil, Light/Dark, Tastatur- und Touchalternativen,
+Planung, Live-Ausgabe sowie anonyme Ausgabedaten wurden geprüft. Reales OBS und
+echte YouTube-/TikTok-Wiedergabe bleiben mangels verfügbarer Umgebung offen.
+
+## Materialkorrektur 0.5.7
+
+- statische Gold-/Blauviolettlichter so positioniert und verstärkt, dass sie im
+  eigentlichen Arbeitsbereich statt fast ausschließlich hinter der Navigation
+  sichtbar werden
+- gemeinsame Materialtokens auf Außenglas, dunkle Innenfläche und tiefe
+  Ablaufkarte reduziert; verschachtelte Abschnitte, Pieces und Aktionsgruppen
+  werden nach innen dunkler statt heller und blaugrau
+- aktive Editortabs transparent goldgetönt und private Recherche sowie
+  Quellen-/Materialbereiche auf transparente Nachtblauflächen zurückgeführt
+- Dialog-Backdrop von starker Abdunklung und Unschärfe auf eine leichtere
+  Trennung reduziert, sodass die Lichtstimmung bei geöffnetem Editor erhalten
+  bleibt
+- deckende Schreibfelder, Goldfokus, Lightmode, Mobilansicht und lesbare
+  Komponentenfüllungen ohne verfügbaren Blur bleiben erhalten
+
+Die berechneten Hintergründe, Transparenzen, Filter und Begrenzungseigenschaften
+wurden vor und nach der Korrektur in Chromium kontrolliert. Sendungsplanung,
+Sendungstext und Recherche wurden bei 1440 × 1000 und 390 × 844 Pixeln in beiden
+Themes visuell geprüft.
+
+## Oberflächenkorrektur 0.5.6
+
+- sichtbare statische Gold- und Blauviolettlichter hinter den halbtransparenten
+  Navigations- und Editorflächen
+- klarere Glaswirkung in Navigation sowie Kopf, Tabs und Fuß des Piece-Editors;
+  Schreibflächen bleiben deckend, ruhig und goldfokussiert
+- Fundus mit dauerhaft sichtbarer Suche und Neuanlage, aufklappbaren Zusatzfiltern
+  und inhaltsorientierten, vollständig anklickbaren Zeilen
+- vorhandene Vorschaubilder beziehungsweise kleine Symbolplatzhalter sowie
+  gebündelte Menüs für Duplizieren und Archivieren
+- bestehende Server-Actions, Filterlogik und Editor-Bereiche unverändert
+
+Geprüft wurden `npm run check` sowie Fundus und geöffneter Piece-Editor in
+Chromium bei 1440 × 1000 und 390 × 844 Pixeln in Light/Dark. Die gezielte
+Kontrolle umfasste Tastaturöffnung, Menüs, Fokus, Glaswerte, Seitenüberlauf und
+visuell geprüfte Screenshots. Produktionsbuild und vollständige Testmatrix wurden
+gemäß Auftrag nicht ausgeführt.
+
+## Oberflächenkorrektur 0.5.5
+
+- dunkle Grundfläche mit sehr zurückhaltenden Gold-/Cyan-Lichtfeldern innerhalb
+  der Anwendung statt gleichmäßig deckender Blauflächen
+- Navigation, große Arbeitsflächen und Piece-Dialog als dunkles beziehungsweise
+  helles Glas mit feiner Lichtkante, Unschärfe und ruhigem Schatten
+- Gold für Dialogkontur, Fokus, aktive Zustände und Hauptaktionen; Cyan nur noch
+  für ergänzende redaktionelle Hinweise und Links
+- klar abgegrenzte, weitgehend deckende Schreibfelder mit Goldfokus, Platzhaltern
+  und nach Textrolle abgestuften Höhen
+- bestehende nachträgliche CSS-Override-Schicht entfernt und die Gestaltung in
+  gemeinsame Tokens und ursprüngliche Komponentenregeln zurückgeführt
+
+Geprüft wurden Typen, Produktionsbuild sowie gezielte Chromium-Ansichten von
+Eingang, Fundus, Piece-Editor, Sendungsplanung und Live-Steuerung bei 1440 × 1000
+und 390 × 844 Pixeln in beiden Themes. Die vollständige Unit- und E2E-Matrix
+bleibt wie beauftragt Schritt 3 vorbehalten.
+
+## Oberflächenrelease 0.5.4
+
+- gemeinsame Light-/Dark-Tokens für ruhige Arbeitsflächen, Cyan als
+  Interaktionsfarbe und Gold für die jeweilige Hauptaktion
+- Darkmode im heinzlive-Farbraum mit Hintergrund `#0B1220`, Flächen `#152238`,
+  Text `#FFF7E8`, Sekundärtext `#A9B6C8`, Gold `#E7B957`, Cyan `#67DDE8` und
+  Grenzen `#30435C`
+- vereinheitlichte Navigation, Formulare, Meldungen, Listen, Sendungsplan,
+  Live-Steuerung und Piece-Dialoge ohne Änderung der Bedienlogik
+- kompaktere Planzeilen mit sichtbarem Drag-Griff und waagerechter Aktionsgruppe;
+  Klick-, Touch- und Tastaturalternativen bleiben erhalten
+- verständliche Kontextnamen „Fundusfassung“ und „Sendungsfassung“ sowie weniger
+  technische Erläuterungen im redaktionellen Arbeitsfluss
+- dezente Speicheraktion im gespeicherten Zustand und hervorgehobene Aktion bei
+  ungespeicherten Änderungen, Fehlern oder Konflikten
+
+Für diesen Design-Release wurden `npm run check`, `npm run build` und gezielte
+Chromium-Sichtkontrollen auf Eingang, Fundus, Piece-Editor, Sendungsplan und
+Live-Steuerung bei 1440 × 1000 sowie 390 × 844 Pixeln in Light/Dark ausgeführt.
+Konsolenfehler und horizontaler Seitenüberlauf traten dabei nicht auf. Die
+vollständige Unit- und E2E-Matrix wurde für die rein visuelle Änderung bewusst
+nicht erneut ausgeführt; die fachlichen Nachweise der Etappen 1 bis 5 bleiben
+unverändert.
 
 ## Umgesetzter Stand Etappe 1
 
@@ -37,9 +197,8 @@ umgebrochen.
 
 ## Noch nicht umgesetzt
 
-Echte Live-Steuerung, Präsentationsfenster, Archivabschluss, Freigaben, RSS und
+Archivabschluss, Freigaben, RSS und API. Diese späteren Bereiche dürfen nicht
-API. Die verbleibenden Vorschauen dürfen nicht als
+als bereits implementiert verstanden werden.
-Implementierung dieser späteren Funktionen verstanden werden.
 
 ## Umgesetzter Stand Etappe 2
 
@@ -67,6 +226,32 @@ Implementierung dieser späteren Funktionen verstanden werden.
 - Archivieren und Wiederherstellen in den vorherigen Arbeitsstatus
 - private Rasterbilder mit Größen-/Signaturprüfung und geschützter Auslieferung
 - erweiterter Seed mit Eingangs-, Archiv-, Markdown- und Recherchebeispielen
+- standardmäßig ausgeblendete gesendete Pieces mit verlinkter, aufklappbarer
+  Verwendungshistorie; gesendet bedeutet erledigt in abgeschlossener Sendung
+- standardmäßig ausgeblendete Pieces, die in mindestens einer noch nicht
+  abgeschlossenen Sendung eingeplant sind, mit unabhängigem Sofortfilter
+- Fundus-Originale und sendungsspezifische Verwendungen nutzen denselben
+  großzügigen Dialograhmen mit den Bereichen „Sendungstext“, „Recherche &
+  Quellen“ und „Präsentation“; der jeweilige Speicherkontext ist sichtbar und
+  Original sowie Verwendung bleiben getrennte Revisionsgrenzen
+- Titel, Einleitung, Moderationsstichpunkte und Überleitung sind ohne
+  vorgeschaltete Lese-/Bearbeitungsschalter direkt beschreibbar; eine kleine
+  Markdown-Leiste ergänzt Formatierung ohne Änderung des Speicherformats
+- Recherche, Quellen, verwendungseigene Notizen und Material sind in einem
+  Bereich gebündelt; öffentliche Texte, Darstellungswahl und tatsächliche
+  Vorschau stehen gemeinsam im Präsentationsbereich
+- der Dialog bleibt innerhalb der Desktop-Fensterhöhe, hält Kopf,
+  Bereichsnavigation und Aktionen sichtbar und nutzt mobil die volle
+  Bildschirmfläche; Bereichswechsel hängen Eingaben nicht aus und merken die
+  jeweilige Scrollposition
+- die Schnellaufnahme akzeptiert Gedanke oder URL, bleibt nach dem Ablegen im
+  Eingang und öffnet die Ausarbeitung erst über eine bewusste Aktion
+
+Für diese gezielte Überarbeitung wurden `npm run check` sowie kurze
+Chromium-Sichtkontrollen des Original- und Verwendungseditors bei 1440 × 1000
+und 390 × 844 Pixeln ausgeführt. Dabei waren Dialoggrenzen, feste Bedienbereiche,
+alle drei Arbeitsbereiche und horizontaler Überlauf unauffällig. Die vollständige
+Unit-, E2E- und Build-Matrix ist gemäß Auftrag noch offen.
 
 ## Umgesetzter Stand Etappe 4
 
@@ -78,6 +263,12 @@ Implementierung dieser späteren Funktionen verstanden werden.
 - showweite Reservebank, die nicht in Abschnitts- oder Gesamtdauer einfließt
 - explizite Abschnittsdauer ersetzt die Piece-Summe statt sie zu addieren
 - Bearbeiten, Entfernen sowie Verschieben innerhalb und zwischen Abschnitten
+- zugänglicher Stift-Dialog für alle sendungsspezifischen Felder und Aktionen,
+  auf Desktop zweispaltig und auf kleinen Bildschirmen einspaltig scrollbar
+- explizites Aktualisieren eines Verwendungssnapshots aus dem Original für
+  Titel, Dauer und Redaktionstexte bei erhaltenen Notizen und Live-Daten
+- Duplizieren einer konkreten Einplanung direkt hinter dem Ausgangselement mit
+  erhaltenen Anpassungen, aber zurückgesetztem Live-Zustand
 - Piece-Dauern werden im Editor in Minuten eingegeben und intern weiterhin als
   ganze Sekunden gespeichert
 - Drag-and-drop über eindeutige Griffe, auch direkt aus gefilterten Quellen,
@@ -85,11 +276,40 @@ Implementierung dieser späteren Funktionen verstanden werden.
   gleichwertigen Klick-, Touch- und Tastaturaktionen
 - Planungsmutationen ohne Dokumentreload mit lokalem Speicherzustand und
   animierter Neusortierung der betroffenen Elemente
+- unabhängige Sofortfilter für verwendete sowie in der aktuellen Sendung schon
+  eingeplante Originale einschließlich Reservebank
 - kopierbare Twitch-Titel und Ankündigungstexte
 - showweite optimistische Revision schützt Metadaten, Reihenfolge und Inhalte
   vor unbemerktem parallelem Überschreiben
 - realistischer Seed mit Standardablauf und eigenständigem Spieleabend
 
+## Umgesetzter Stand Etappe 5
+
+- fokussierte Moderationsansicht mit Prompter-Schrift, Einleitung, Moderation,
+  Überleitung und standardmäßig geschlossener privater Recherche
+- ausblendbare Zeit- und Ablaufanzeige sowie persistente lokale Leseposition
+- aktuelles und nächstes Piece samt Abschnitt und geplantem Zeitbedarf
+- persistenter Live-Stand mit tatsächlichen Laufintervallen, Erledigen,
+  Überspringen, Zurück und Wiederaufnahme
+- idempotente Live-Befehle verhindern doppelte Wirkung bei Wiederholung
+- serverseitig geschützte Umsortierung offener Pieces und Reserveeinfügung
+- explizite Präsentationsaktion; normale Live-Navigation verändert die Ausgabe
+  nicht
+- getrennte, tokenisierte heinzlive-Ausgabe mit Polling, Verbindungsanzeige,
+  Präsentationstext, Quellen und erlaubten Bildern
+- wählbare Text-, Linkkarten- und Videodarstellung aus genau einer vorhandenen
+  Piece-Quelle mit manuell korrigierbaren, persistenten Metadaten
+- ausdrückliches serverseitiges Neuladen von Linkmetadaten über Metascraper mit
+  DNS-, Redirect-, Zeit-, Größen- und Privatnetzschutz
+- validierte YouTube- und TikTok-IDs, offizielle Player-Iframes ohne Autoplay
+  sowie Linkkarten-Fallback für nicht unterstützte Videoquellen
+- unveränderliche Präsentationssnapshots je Einplanung und explizite
+  Aktualisierung aus dem Fundus
+- isolierte Präsentationstestansicht ohne Änderung des Live-Stands sowie
+  tokengebundene, serverseitig geschützte Proxys für externe Vorschaubilder
+- Ausgabe-HTML, JSON und Medienzugriff enthalten keine Recherche,
+  Moderationsnotizen, eigenen Notizen, Kontodaten oder internen Dateipfade
+
 ## Bekannte offene Betriebsprüfung
 
 Eine echte Cloudron-Installation samt Backup/Restore, Reverse-Proxy-Verhalten
@@ -98,6 +318,15 @@ durchgeführt werden. Auch der lokale Container-Smoke-Test blieb offen, weil
 auf der Prüfmaschine kein Docker-Daemon lief. Manifestkernfelder und
 Startskript-Syntax wurden lokal geprüft.
 
+Eine reale OBS-Browserquelle stand nicht zur Verfügung. Die tokenisierte
+Präsentationsausgabe wurde stattdessen in einem anonymen zweiten Chromium-
+Browserkontext einschließlich Bild, JSON-Filterung, Polling und sichtbarem
+Verbindungsabbruch geprüft.
+
+Die automatisierten Playerprüfungen fingen YouTube- und TikTok-Requests lokal
+ab. URL-Erkennung, Iframe-Wechsel, Zeitmarkenübergabe und mobile Ausgabe sind
+damit geprüft, nicht jedoch die reale Wiedergabe oder Verfügbarkeit der Anbieter.
+
 ## Verifizierte Umgebung
 
 - Node.js 22.23.1, npm 10.9.8

migrations/0005_live_mode.sql

@@ -0,0 +1,45 @@
+CREATE TABLE show_live_states (
+	show_id TEXT PRIMARY KEY REFERENCES shows(id) ON DELETE CASCADE,
+	revision INTEGER NOT NULL DEFAULT 0 CHECK (revision >= 0),
+	current_usage_id TEXT REFERENCES piece_usages(id) ON DELETE SET NULL,
+	started_at_utc TEXT,
+	ended_at_utc TEXT,
+	presentation_usage_id TEXT REFERENCES piece_usages(id) ON DELETE SET NULL,
+	presentation_revision INTEGER NOT NULL DEFAULT 0 CHECK (presentation_revision >= 0),
+	updated_at_utc TEXT NOT NULL
+);
+
+CREATE TABLE live_usage_runs (
+	id TEXT PRIMARY KEY,
+	show_id TEXT NOT NULL REFERENCES shows(id) ON DELETE CASCADE,
+	usage_id TEXT NOT NULL REFERENCES piece_usages(id) ON DELETE CASCADE,
+	started_at_utc TEXT NOT NULL,
+	ended_at_utc TEXT,
+	CHECK (ended_at_utc IS NULL OR ended_at_utc >= started_at_utc)
+);
+
+CREATE UNIQUE INDEX idx_one_active_live_run_per_show
+	ON live_usage_runs(show_id) WHERE ended_at_utc IS NULL;
+CREATE INDEX idx_live_runs_usage ON live_usage_runs(usage_id, started_at_utc);
+
+CREATE TABLE live_commands (
+	show_id TEXT NOT NULL REFERENCES shows(id) ON DELETE CASCADE,
+	command_id TEXT NOT NULL,
+	action TEXT NOT NULL,
+	result_revision INTEGER NOT NULL CHECK (result_revision >= 0),
+	created_at_utc TEXT NOT NULL,
+	PRIMARY KEY (show_id, command_id)
+);
+
+CREATE TABLE presentation_access_tokens (
+	id TEXT PRIMARY KEY,
+	show_id TEXT NOT NULL REFERENCES shows(id) ON DELETE CASCADE,
+	token_hash TEXT NOT NULL UNIQUE,
+	created_at_utc TEXT NOT NULL,
+	revoked_at_utc TEXT
+);
+
+CREATE INDEX idx_presentation_tokens_show
+	ON presentation_access_tokens(show_id, revoked_at_utc);
+
+UPDATE piece_usages SET status = 'open' WHERE status = 'current';

migrations/0006_presentation_previews.sql

@@ -0,0 +1,28 @@
+ALTER TABLE pieces ADD COLUMN presentation_mode TEXT NOT NULL DEFAULT 'text'
+	CHECK (presentation_mode IN ('text', 'link', 'video'));
+ALTER TABLE pieces ADD COLUMN presentation_source_position INTEGER;
+ALTER TABLE pieces ADD COLUMN presentation_title TEXT NOT NULL DEFAULT '';
+ALTER TABLE pieces ADD COLUMN presentation_description TEXT NOT NULL DEFAULT '';
+ALTER TABLE pieces ADD COLUMN presentation_image_url TEXT NOT NULL DEFAULT '';
+ALTER TABLE pieces ADD COLUMN presentation_site_name TEXT NOT NULL DEFAULT '';
+ALTER TABLE pieces ADD COLUMN presentation_provider TEXT NOT NULL DEFAULT '';
+ALTER TABLE pieces ADD COLUMN presentation_provider_id TEXT NOT NULL DEFAULT '';
+ALTER TABLE pieces ADD COLUMN presentation_title_manual INTEGER NOT NULL DEFAULT 0
+	CHECK (presentation_title_manual IN (0, 1));
+ALTER TABLE pieces ADD COLUMN presentation_description_manual INTEGER NOT NULL DEFAULT 0
+	CHECK (presentation_description_manual IN (0, 1));
+ALTER TABLE pieces ADD COLUMN presentation_image_manual INTEGER NOT NULL DEFAULT 0
+	CHECK (presentation_image_manual IN (0, 1));
+ALTER TABLE pieces ADD COLUMN presentation_metadata_fetched_at_utc TEXT;
+
+ALTER TABLE piece_usages ADD COLUMN presentation_mode_snapshot TEXT NOT NULL DEFAULT 'text'
+	CHECK (presentation_mode_snapshot IN ('text', 'link', 'video'));
+ALTER TABLE piece_usages ADD COLUMN presentation_source_label_snapshot TEXT NOT NULL DEFAULT '';
+ALTER TABLE piece_usages ADD COLUMN presentation_source_url_snapshot TEXT NOT NULL DEFAULT '';
+ALTER TABLE piece_usages ADD COLUMN presentation_source_timecode_snapshot INTEGER;
+ALTER TABLE piece_usages ADD COLUMN presentation_title_meta_snapshot TEXT NOT NULL DEFAULT '';
+ALTER TABLE piece_usages ADD COLUMN presentation_description_snapshot TEXT NOT NULL DEFAULT '';
+ALTER TABLE piece_usages ADD COLUMN presentation_image_url_snapshot TEXT NOT NULL DEFAULT '';
+ALTER TABLE piece_usages ADD COLUMN presentation_site_name_snapshot TEXT NOT NULL DEFAULT '';
+ALTER TABLE piece_usages ADD COLUMN presentation_provider_snapshot TEXT NOT NULL DEFAULT '';
+ALTER TABLE piece_usages ADD COLUMN presentation_provider_id_snapshot TEXT NOT NULL DEFAULT '';

migrations/0007_editorial_workflows.sql

@@ -0,0 +1,58 @@
+ALTER TABLE pieces ADD COLUMN output_title TEXT NOT NULL DEFAULT '';
+ALTER TABLE piece_usages ADD COLUMN output_title_snapshot TEXT NOT NULL DEFAULT '';
+
+CREATE TABLE piece_templates (
+	id TEXT PRIMARY KEY,
+	name TEXT NOT NULL UNIQUE,
+	description TEXT NOT NULL DEFAULT '',
+	snapshot_json TEXT NOT NULL CHECK (json_valid(snapshot_json)),
+	revision INTEGER NOT NULL DEFAULT 1 CHECK (revision >= 1),
+	created_at_utc TEXT NOT NULL,
+	updated_at_utc TEXT NOT NULL
+);
+
+INSERT INTO piece_templates (
+	id, name, description, snapshot_json, revision, created_at_utc, updated_at_utc
+) VALUES
+	(
+		'talk', 'Gespräch',
+		'Leitfragen, Recherche und eine klare Überleitung.',
+		'{"title":"Unbenanntes Gespräch","formatId":"format-talk","moderationNotes":"## Leitfragen\n\n- ","categoryIds":["cat-jc"]}',
+		1, '2026-10-23T00:00:00.000Z', '2026-10-23T00:00:00.000Z'
+	),
+	(
+		'find', 'Reaction / Fundstück',
+		'Quelle, Einordnung und präsentierbare Kernaussage.',
+		'{"title":"Neues Fundstück","formatId":"format-find","presentationText":"## Kernaussage\n\n","categoryIds":["cat-reaction"]}',
+		1, '2026-10-23T00:00:00.000Z', '2026-10-23T00:00:00.000Z'
+	),
+	(
+		'interaction', 'Interaktion',
+		'Quiz, Publikumsfrage oder kleines Spiel.',
+		'{"title":"Neue Interaktion","formatId":"format-quiz","moderationNotes":"## Ablauf\n\n1. ","categoryIds":["cat-game"]}',
+		1, '2026-10-23T00:00:00.000Z', '2026-10-23T00:00:00.000Z'
+	);
+
+CREATE TABLE planning_commands (
+	show_id TEXT NOT NULL REFERENCES shows(id) ON DELETE CASCADE,
+	command_id TEXT NOT NULL,
+	piece_id TEXT NOT NULL REFERENCES pieces(id) ON DELETE CASCADE,
+	usage_id TEXT NOT NULL REFERENCES piece_usages(id) ON DELETE CASCADE,
+	result_revision INTEGER NOT NULL CHECK (result_revision >= 1),
+	created_at_utc TEXT NOT NULL,
+	PRIMARY KEY (show_id, command_id)
+);
+
+CREATE TABLE presentation_channels (
+	id TEXT PRIMARY KEY,
+	name TEXT NOT NULL,
+	access_key TEXT NOT NULL,
+	key_hash TEXT NOT NULL UNIQUE,
+	show_id TEXT REFERENCES shows(id) ON DELETE SET NULL,
+	revision INTEGER NOT NULL DEFAULT 0 CHECK (revision >= 0),
+	created_at_utc TEXT NOT NULL,
+	updated_at_utc TEXT NOT NULL
+);
+
+UPDATE presentation_access_tokens
+SET revoked_at_utc = COALESCE(revoked_at_utc, '2026-10-23T00:00:00.000Z');

migrations/0008_durable_planning_commands.sql

@@ -0,0 +1,18 @@
+CREATE TABLE planning_commands_durable (
+	show_id TEXT NOT NULL REFERENCES shows(id) ON DELETE CASCADE,
+	command_id TEXT NOT NULL,
+	piece_id TEXT NOT NULL,
+	usage_id TEXT NOT NULL,
+	result_revision INTEGER NOT NULL CHECK (result_revision >= 1),
+	created_at_utc TEXT NOT NULL,
+	PRIMARY KEY (show_id, command_id)
+);
+
+INSERT INTO planning_commands_durable (
+	show_id, command_id, piece_id, usage_id, result_revision, created_at_utc
+)
+SELECT show_id, command_id, piece_id, usage_id, result_revision, created_at_utc
+FROM planning_commands;
+
+DROP TABLE planning_commands;
+ALTER TABLE planning_commands_durable RENAME TO planning_commands;

migrations/0009_live_workbench.sql

@@ -0,0 +1,102 @@
+ALTER TABLE pieces ADD COLUMN is_favorite INTEGER NOT NULL DEFAULT 0
+	CHECK (is_favorite IN (0, 1));
+
+CREATE TABLE tools (
+	id TEXT PRIMARY KEY,
+	name TEXT NOT NULL UNIQUE,
+	start_url TEXT NOT NULL DEFAULT '',
+	description TEXT NOT NULL DEFAULT '',
+	is_active INTEGER NOT NULL DEFAULT 1 CHECK (is_active IN (0, 1)),
+	created_at_utc TEXT NOT NULL,
+	updated_at_utc TEXT NOT NULL
+);
+
+CREATE TABLE tool_formats (
+	tool_id TEXT NOT NULL REFERENCES tools(id) ON DELETE CASCADE,
+	format_id TEXT NOT NULL REFERENCES formats(id) ON DELETE CASCADE,
+	PRIMARY KEY (tool_id, format_id)
+);
+
+CREATE TABLE piece_tools (
+	id TEXT PRIMARY KEY,
+	piece_id TEXT NOT NULL REFERENCES pieces(id) ON DELETE CASCADE,
+	tool_id TEXT NOT NULL REFERENCES tools(id) ON DELETE RESTRICT,
+	work_url TEXT NOT NULL DEFAULT '',
+	note TEXT NOT NULL DEFAULT '',
+	position INTEGER NOT NULL CHECK (position >= 0),
+	UNIQUE (piece_id, tool_id),
+	UNIQUE (piece_id, position)
+);
+
+CREATE TABLE usage_source_snapshots (
+	id TEXT PRIMARY KEY,
+	usage_id TEXT NOT NULL REFERENCES piece_usages(id) ON DELETE CASCADE,
+	label TEXT NOT NULL,
+	url TEXT NOT NULL,
+	timecode_seconds INTEGER CHECK (timecode_seconds IS NULL OR timecode_seconds >= 0),
+	position INTEGER NOT NULL CHECK (position >= 0),
+	UNIQUE (usage_id, position)
+);
+
+CREATE TABLE usage_tool_snapshots (
+	id TEXT PRIMARY KEY,
+	usage_id TEXT NOT NULL REFERENCES piece_usages(id) ON DELETE CASCADE,
+	original_tool_id TEXT REFERENCES tools(id) ON DELETE SET NULL,
+	name TEXT NOT NULL,
+	start_url TEXT NOT NULL DEFAULT '',
+	work_url TEXT NOT NULL DEFAULT '',
+	note TEXT NOT NULL DEFAULT '',
+	position INTEGER NOT NULL CHECK (position >= 0),
+	UNIQUE (usage_id, position)
+);
+
+CREATE TABLE usage_topic_snapshots (
+	usage_id TEXT NOT NULL REFERENCES piece_usages(id) ON DELETE CASCADE,
+	name TEXT NOT NULL,
+	position INTEGER NOT NULL CHECK (position >= 0),
+	PRIMARY KEY (usage_id, position)
+);
+
+CREATE TABLE live_section_timers (
+	id TEXT PRIMARY KEY,
+	show_id TEXT NOT NULL REFERENCES shows(id) ON DELETE CASCADE,
+	section_id TEXT NOT NULL REFERENCES show_sections(id) ON DELETE CASCADE,
+	planned_duration_seconds INTEGER NOT NULL CHECK (planned_duration_seconds > 0),
+	started_at_utc TEXT NOT NULL,
+	ended_at_utc TEXT,
+	CHECK (ended_at_utc IS NULL OR ended_at_utc >= started_at_utc)
+);
+
+CREATE TABLE live_section_timer_runs (
+	id TEXT PRIMARY KEY,
+	timer_id TEXT NOT NULL REFERENCES live_section_timers(id) ON DELETE CASCADE,
+	started_at_utc TEXT NOT NULL,
+	ended_at_utc TEXT,
+	CHECK (ended_at_utc IS NULL OR ended_at_utc >= started_at_utc)
+);
+
+CREATE INDEX idx_piece_tools_piece ON piece_tools(piece_id, position);
+CREATE INDEX idx_tool_formats_format ON tool_formats(format_id, tool_id);
+CREATE INDEX idx_usage_sources_usage ON usage_source_snapshots(usage_id, position);
+CREATE INDEX idx_usage_tools_usage ON usage_tool_snapshots(usage_id, position);
+CREATE UNIQUE INDEX idx_one_open_section_timer_per_show
+	ON live_section_timers(show_id) WHERE ended_at_utc IS NULL;
+CREATE UNIQUE INDEX idx_one_open_run_per_section_timer
+	ON live_section_timer_runs(timer_id) WHERE ended_at_utc IS NULL;
+
+INSERT INTO usage_source_snapshots (
+	id, usage_id, label, url, timecode_seconds, position
+)
+SELECT lower(hex(randomblob(16))), u.id, ps.label, ps.url, ps.timecode_seconds, ps.position
+FROM piece_usages u
+JOIN piece_sources ps ON ps.piece_id = u.original_piece_id;
+
+INSERT INTO usage_topic_snapshots (usage_id, name, position)
+SELECT usage_id, name, position
+FROM (
+	SELECT u.id AS usage_id, t.name,
+		row_number() OVER (PARTITION BY u.id ORDER BY t.name, t.id) - 1 AS position
+	FROM piece_usages u
+	JOIN piece_topics pt ON pt.piece_id = u.original_piece_id
+	JOIN topics t ON t.id = pt.topic_id
+);

migrations/0010_editor_experience.sql

@@ -0,0 +1,49 @@
+ALTER TABLE topics ADD COLUMN icon_name TEXT NOT NULL DEFAULT '';
+
+ALTER TABLE pieces ADD COLUMN deleted_at_utc TEXT;
+
+ALTER TABLE piece_media ADD COLUMN removed_at_utc TEXT;
+
+CREATE TABLE piece_presentation_media (
+	piece_id TEXT PRIMARY KEY REFERENCES pieces(id) ON DELETE CASCADE,
+	media_id TEXT NOT NULL UNIQUE REFERENCES piece_media(id) ON DELETE RESTRICT
+);
+
+CREATE TRIGGER validate_piece_presentation_media_insert
+BEFORE INSERT ON piece_presentation_media
+WHEN NOT EXISTS (
+	SELECT 1 FROM piece_media
+	WHERE id = NEW.media_id AND piece_id = NEW.piece_id AND removed_at_utc IS NULL
+)
+BEGIN
+	SELECT RAISE(ABORT, 'presentation media does not belong to piece');
+END;
+
+CREATE TRIGGER validate_piece_presentation_media_update
+BEFORE UPDATE ON piece_presentation_media
+WHEN NOT EXISTS (
+	SELECT 1 FROM piece_media
+	WHERE id = NEW.media_id AND piece_id = NEW.piece_id AND removed_at_utc IS NULL
+)
+BEGIN
+	SELECT RAISE(ABORT, 'presentation media does not belong to piece');
+END;
+
+ALTER TABLE usage_topic_snapshots ADD COLUMN icon_name TEXT NOT NULL DEFAULT '';
+
+CREATE TABLE usage_media_snapshots (
+	id TEXT PRIMARY KEY,
+	usage_id TEXT NOT NULL REFERENCES piece_usages(id) ON DELETE CASCADE,
+	original_media_id TEXT NOT NULL REFERENCES piece_media(id) ON DELETE RESTRICT,
+	alt_text TEXT NOT NULL DEFAULT '',
+	position INTEGER NOT NULL CHECK (position >= 0),
+	is_presentation INTEGER NOT NULL DEFAULT 0 CHECK (is_presentation IN (0, 1)),
+	UNIQUE (usage_id, position)
+);
+
+CREATE INDEX idx_pieces_deleted_at ON pieces(deleted_at_utc);
+CREATE INDEX idx_piece_media_active ON piece_media(piece_id, position)
+	WHERE removed_at_utc IS NULL;
+CREATE INDEX idx_usage_media_usage ON usage_media_snapshots(usage_id, position);
+CREATE UNIQUE INDEX idx_one_presentation_media_per_usage
+	ON usage_media_snapshots(usage_id) WHERE is_presentation = 1;

migrations/0011_tool_icons.sql

@@ -0,0 +1 @@
+ALTER TABLE tools ADD COLUMN icon_name TEXT NOT NULL DEFAULT 'wrench';

package.json

@@ -1,7 +1,7 @@
 {
 	"name": "sendewerk",
 	"private": true,
-	"version": "0.4.0",
+	"version": "0.5.10",
 	"type": "module",
 	"engines": {
 		"node": ">=22.17 <25"
@@ -28,6 +28,11 @@
 		"better-sqlite3": "^13.0.3",
 		"file-type": "^22.2.0",
 		"marked": "^18.1.1",
+		"metascraper": "^5.58.5",
+		"metascraper-description": "^5.58.4",
+		"metascraper-image": "^5.58.4",
+		"metascraper-publisher": "^5.58.4",
+		"metascraper-title": "^5.58.4",
 		"nodemailer": "^10.1.7",
 		"sanitize-html": "^2.18.1"
 	},

scripts/generate-classic-regular-icons.mjs

@@ -0,0 +1,51 @@
+import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+
+const sourceRoot = process.argv[2];
+if (!sourceRoot) {
+	throw new Error('Usage: node scripts/generate-classic-regular-icons.mjs <font-awesome-web-root>');
+}
+
+const javascript = readFileSync(path.join(sourceRoot, 'js', 'regular.js'), 'utf8');
+const metadata = JSON.parse(readFileSync(path.join(sourceRoot, 'metadata', 'icons.json'), 'utf8'));
+const start = javascript.indexOf('  var icons = ') + '  var icons = '.length;
+const end = javascript.indexOf('\n  };', start) + '\n  }'.length;
+if (start < '  var icons = '.length || end < start)
+	throw new Error('Classic Regular icons not found');
+
+const definitions = JSON.parse(javascript.slice(start, end));
+const icons = Object.keys(definitions)
+	.map((name) => {
+		const details = metadata[name];
+		return {
+			name,
+			label: details?.label ?? name.replaceAll('-', ' '),
+			terms: details?.search?.terms ?? []
+		};
+	})
+	.sort((left, right) => left.label.localeCompare(right.label, 'en'));
+
+const output = `// Generated from Font Awesome Pro Plus 7.0.0 Classic Regular metadata.
+// Covered by the Font Awesome Pro commercial license; see THIRD_PARTY_NOTICES.md.
+export type ClassicRegularIcon = {
+\tname: string;
+\tlabel: string;
+\tterms: readonly string[];
+};
+
+export const classicRegularIcons: readonly ClassicRegularIcon[] = ${JSON.stringify(icons)};
+
+export type IconName = string;
+
+export const classicRegularIconNames = new Set<string>(
+	classicRegularIcons.map((icon) => icon.name)
+);
+`;
+
+writeFileSync('src/lib/icons/classic-regular.ts', output);
+mkdirSync('static/icons', { recursive: true });
+copyFileSync(
+	path.join(sourceRoot, 'sprites-full', 'regular.svg'),
+	'static/icons/classic-regular.svg'
+);
+console.log(`Generated ${icons.length} Classic Regular icons.`);

scripts/seed.mjs

@@ -348,7 +348,7 @@ export function seed(databasePath = getPaths().database) {
 					'section-stories',
 					'piece-console',
 					0,
-					'current',
+					'open',
 					480,
 					'Die kleine Konsole mit dem großen Dreh',
 					'Eine Kurbel, ein gelber Knopf und sehr viel Charme: Was macht kleine Hardware spannend?',
@@ -425,6 +425,28 @@ export function seed(databasePath = getPaths().database) {
 				]
 			]
 		);
+		database.prepare('DELETE FROM usage_source_snapshots').run();
+		database
+			.prepare(
+				`INSERT INTO usage_source_snapshots
+				 (id, usage_id, label, url, timecode_seconds, position)
+				 SELECT 'seed-source-' || u.id || '-' || ps.position, u.id, ps.label, ps.url,
+				 ps.timecode_seconds, ps.position
+				 FROM piece_usages u JOIN piece_sources ps ON ps.piece_id = u.original_piece_id`
+			)
+			.run();
+		database.prepare('DELETE FROM usage_topic_snapshots').run();
+		database
+			.prepare(
+				`INSERT INTO usage_topic_snapshots (usage_id, name, position)
+				 SELECT usage_id, name, position FROM (
+					SELECT u.id AS usage_id, t.name,
+					row_number() OVER (PARTITION BY u.id ORDER BY t.name, t.id) - 1 AS position
+					FROM piece_usages u JOIN piece_topics pt ON pt.piece_id = u.original_piece_id
+					JOIN topics t ON t.id = pt.topic_id
+				 )`
+			)
+			.run();
 	});
 
 	seedDatabase();

src/app.d.ts

@@ -7,6 +7,7 @@ declare global {
 		}
 		interface PageData {
 			user?: AuthUser | null;
+			presentationMode?: boolean;
 		}
 	}
 }

src/hooks.server.ts

@@ -13,11 +13,13 @@ const publicPaths = new Set([
 ]);
 
 export const handle: Handle = async ({ event, resolve }) => {
+	const presentationPath = event.url.pathname.startsWith('/heinzlive/');
+	const presentationTestPath = /^\/fundus\/[^/]+\/praesentation(?:\/|$)/.test(event.url.pathname);
 	const token = event.cookies.get(SESSION_COOKIE);
 	event.locals.user = getSessionUser(token);
 	if (token && !event.locals.user) deleteSession(event.cookies);
 
-	if (!publicPaths.has(event.url.pathname) && !event.locals.user) {
+	if (!presentationPath && !publicPaths.has(event.url.pathname) && !event.locals.user) {
 		redirect(303, hasUsers() ? '/login' : '/setup');
 	}
 
@@ -25,6 +27,14 @@ export const handle: Handle = async ({ event, resolve }) => {
 	response.headers.set('Referrer-Policy', 'same-origin');
 	response.headers.set('X-Content-Type-Options', 'nosniff');
 	response.headers.set('X-Frame-Options', 'DENY');
+	if (presentationPath || presentationTestPath) {
+		response.headers.set('Cache-Control', 'no-store');
+		response.headers.set('Referrer-Policy', 'strict-origin-when-cross-origin');
+		response.headers.set(
+			'Content-Security-Policy',
+			"frame-src https://www.youtube-nocookie.com https://www.youtube.com https://www.tiktok.com; frame-ancestors 'none'"
+		);
+	}
 	if (event.url.pathname === '/einladung' || event.url.pathname === '/passwort-zuruecksetzen') {
 		response.headers.set('Cache-Control', 'no-store');
 	}

src/lib/components/AppIcon.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">
+	let { name, label, size = '1em' }: { name: string; label?: string; size?: string } = $props();
+</script>
+
+<svg
+	width={size}
+	height={size}
+	role={label ? 'img' : undefined}
+	aria-label={label}
+	aria-hidden={label ? undefined : 'true'}
+	class="app-icon"
+>
+	<use href={`/icons/classic-regular.svg#${name || 'circle'}`} />
+</svg>
+
+<style>
+	.app-icon {
+		display: inline-block;
+		flex: none;
+		fill: currentColor;
+		vertical-align: -0.125em;
+	}
+</style>

src/lib/components/ChoicePicker.svelte

@@ -0,0 +1,90 @@
+<script lang="ts">
+	import AppIcon from './AppIcon.svelte';
+
+	type Item = {
+		id: string;
+		name: string;
+		iconName?: string;
+		description?: string;
+		meta?: string;
+	};
+
+	let {
+		items,
+		selectedIds,
+		label,
+		fieldName,
+		onselectionchange
+	}: {
+		items: Item[];
+		selectedIds: string[];
+		label: string;
+		fieldName?: string;
+		onselectionchange: (ids: string[]) => void;
+	} = $props();
+	let query = $state('');
+	let menu: HTMLDetailsElement;
+	let filtered = $derived(
+		items.filter((item) =>
+			`${item.name} ${item.description ?? ''} ${item.meta ?? ''}`
+				.toLocaleLowerCase('de')
+				.includes(query.trim().toLocaleLowerCase('de'))
+		)
+	);
+	let selected = $derived(items.filter((item) => selectedIds.includes(item.id)));
+
+	function toggle(id: string) {
+		onselectionchange(
+			selectedIds.includes(id)
+				? selectedIds.filter((selectedId) => selectedId !== id)
+				: [...selectedIds, id]
+		);
+	}
+</script>
+
+<div class="choice-picker">
+	{#if fieldName}
+		{#each selectedIds as id (id)}<input type="hidden" name={fieldName} value={id} />{/each}
+	{/if}
+	{#if selected.length}
+		<div class="choice-picker-selected" aria-label={`${label}: ausgewählt`}>
+			{#each selected as item (item.id)}
+				<span
+					>{#if item.iconName}<AppIcon name={item.iconName} />{/if}{item.name}</span
+				>
+			{/each}
+		</div>
+	{/if}
+	<details bind:this={menu} class="choice-picker-menu">
+		<summary>{selected.length ? `${label} ändern` : `${label} auswählen`}</summary>
+		<div class="choice-picker-popover">
+			<label class="choice-picker-search">
+				<span class="sr-only">{label} durchsuchen</span>
+				<AppIcon name="magnifying-glass" />
+				<input type="search" placeholder={`${label} durchsuchen`} bind:value={query} />
+			</label>
+			<div class="choice-picker-options">
+				{#each filtered as item (item.id)}
+					<label class:active={selectedIds.includes(item.id)}>
+						<input
+							type="checkbox"
+							checked={selectedIds.includes(item.id)}
+							onchange={() => toggle(item.id)}
+						/>
+						{#if item.iconName}<AppIcon name={item.iconName} size="1.2em" />{/if}
+						<span
+							><strong>{item.name}</strong>{#if item.description}<small>{item.description}</small
+								>{/if}</span
+						>
+						{#if item.meta}<small>{item.meta}</small>{/if}
+					</label>
+				{:else}<p>Keine Treffer.</p>{/each}
+			</div>
+			<button
+				class="choice-picker-close text-button"
+				type="button"
+				onclick={() => (menu.open = false)}>Auswahl schließen</button
+			>
+		</div>
+	</details>
+</div>

src/lib/components/IconPicker.svelte

@@ -0,0 +1,50 @@
+<script lang="ts">
+	import { classicRegularIcons } from '#lib/icons/classic-regular.js';
+	import AppIcon from './AppIcon.svelte';
+
+	let { name = $bindable(), inputName = 'iconName' }: { name: string; inputName?: string } =
+		$props();
+	let query = $state('');
+	let menu: HTMLDetailsElement;
+	let filtered = $derived(
+		classicRegularIcons.filter((icon) =>
+			`${icon.name} ${icon.label} ${icon.terms.join(' ')}`
+				.toLocaleLowerCase('de')
+				.includes(query.trim().toLocaleLowerCase('de'))
+		)
+	);
+	let visible = $derived(filtered.slice(0, 120));
+</script>
+
+<div class="icon-picker">
+	<input type="hidden" name={inputName} value={name} />
+	<details bind:this={menu}>
+		<summary><AppIcon name={name || 'circle'} /> Icon auswählen</summary>
+		<div class="icon-picker-popover">
+			<label
+				><span class="sr-only">Icons durchsuchen</span><input
+					type="search"
+					placeholder="Icon suchen"
+					bind:value={query}
+				/></label
+			>
+			<div class="icon-picker-grid">
+				{#each visible as icon (icon.name)}
+					<button
+						type="button"
+						class:active={name === icon.name}
+						title={icon.label}
+						onclick={() => {
+							name = icon.name;
+							menu.open = false;
+						}}><AppIcon name={icon.name} /><span>{icon.label}</span></button
+					>
+				{/each}
+			</div>
+			{#if filtered.length > visible.length}<p class="icon-picker-hint">
+					{visible.length} von {filtered.length} Icons sichtbar. Suche verwenden, um weitere Icons zu
+					finden.
+				</p>{/if}
+		</div>
+	</details>
+</div>

src/lib/components/InlineTitleEditor.svelte

@@ -0,0 +1,70 @@
+<script lang="ts">
+	import { tick } from 'svelte';
+	import AppIcon from './AppIcon.svelte';
+
+	let {
+		value = $bindable(),
+		form,
+		name = 'title',
+		label = 'Titel',
+		oncommit
+	}: {
+		value: string;
+		form: string;
+		name?: string;
+		label?: string;
+		oncommit?: () => void;
+	} = $props();
+
+	let editing = $state(false);
+	let original = $state('');
+	let input = $state<HTMLInputElement>();
+	let trigger = $state<HTMLButtonElement>();
+
+	async function edit() {
+		original = value;
+		editing = true;
+		await tick();
+		input?.focus();
+		input?.select();
+	}
+
+	async function finish(commit: boolean) {
+		if (!editing) return;
+		if (!commit) value = original;
+		editing = false;
+		if (commit && value !== original) oncommit?.();
+		await tick();
+		trigger?.focus();
+	}
+</script>
+
+<div class="inline-title-editor">
+	<input type="hidden" {form} {name} {value} />
+	{#if editing}
+		<label>
+			<span class="sr-only">{label}</span>
+			<input
+				bind:this={input}
+				bind:value
+				maxlength="200"
+				required
+				onkeydown={(event) => {
+					if (event.key === 'Enter') {
+						event.preventDefault();
+						void finish(true);
+					} else if (event.key === 'Escape') {
+						event.preventDefault();
+						void finish(false);
+					}
+				}}
+				onblur={() => void finish(true)}
+			/>
+		</label>
+	{:else}
+		<button bind:this={trigger} type="button" class="inline-title-trigger" onclick={edit}>
+			<span>{value}</span><AppIcon name="pen" size="0.9em" />
+			<span class="sr-only">{label} bearbeiten</span>
+		</button>
+	{/if}
+</div>

src/lib/components/MarkdownEditorField.svelte

@@ -0,0 +1,85 @@
+<script lang="ts">
+	import { tick } from 'svelte';
+	import AppIcon from './AppIcon.svelte';
+
+	let {
+		name,
+		label,
+		value = $bindable(),
+		rows = 4,
+		placeholder = '',
+		privateField = false,
+		form
+	}: {
+		name: string;
+		label: string;
+		value: string;
+		rows?: number;
+		placeholder?: string;
+		privateField?: boolean;
+		form?: string;
+	} = $props();
+
+	let textarea: HTMLTextAreaElement;
+
+	async function replaceSelection(before: string, after = before, fallback = 'Text') {
+		const start = textarea.selectionStart;
+		const end = textarea.selectionEnd;
+		const selected = value.slice(start, end) || fallback;
+		value = `${value.slice(0, start)}${before}${selected}${after}${value.slice(end)}`;
+		await tick();
+		textarea.focus();
+		textarea.setSelectionRange(start + before.length, start + before.length + selected.length);
+		textarea.dispatchEvent(new Event('input', { bubbles: true }));
+	}
+
+	async function addList() {
+		const start = textarea.selectionStart;
+		const end = textarea.selectionEnd;
+		const selected = value.slice(start, end) || 'Stichpunkt';
+		const replacement = selected
+			.split('\n')
+			.map((line) => `- ${line}`)
+			.join('\n');
+		value = `${value.slice(0, start)}${replacement}${value.slice(end)}`;
+		await tick();
+		textarea.focus();
+		textarea.setSelectionRange(start + 2, start + replacement.length);
+		textarea.dispatchEvent(new Event('input', { bubbles: true }));
+	}
+</script>
+
+<div class:private-field={privateField} class="markdown-editor-field">
+	<div class="markdown-editor-heading">
+		<span
+			>{label}{#if privateField}<small>Nur intern</small>{/if}</span
+		>
+		<span class="markdown-toolbar" role="toolbar" aria-label={`${label} formatieren`}>
+			<button type="button" aria-label="Fett" title="Fett" onclick={() => replaceSelection('**')}
+				><strong>B</strong></button
+			>
+			<button type="button" aria-label="Kursiv" title="Kursiv" onclick={() => replaceSelection('_')}
+				><em>I</em></button
+			>
+			<button type="button" aria-label="Liste" title="Liste" onclick={addList}
+				><AppIcon name="list-check" /> Liste</button
+			>
+			<button
+				type="button"
+				aria-label="Link"
+				title="Link"
+				onclick={() => replaceSelection('[', '](https://)', 'Linktext')}
+				><AppIcon name="link" /> Link</button
+			>
+		</span>
+	</div>
+	<textarea
+		bind:this={textarea}
+		aria-label={label}
+		{name}
+		{rows}
+		{placeholder}
+		{form}
+		maxlength="50000"
+		bind:value></textarea>
+</div>

src/lib/components/NavIcon.svelte

@@ -1,32 +1,21 @@
 <script lang="ts">
+	import AppIcon from './AppIcon.svelte';
+
 	let { name }: { name: string } = $props();
+	const aliases: Record<string, string> = {
+		library: 'folder-open',
+		shows: 'calendar-days',
+		archive: 'box-archive',
+		settings: 'gear',
+		edit: 'pen'
+	};
+	let iconName = $derived(aliases[name] ?? name);
 </script>
 
-<svg viewBox="0 0 24 24" aria-hidden="true">
+<AppIcon name={iconName} size="1.25rem" />
-	{#if name === 'inbox'}
-		<path d="M4 5.5h16v13H4zM4 14h4l1.5 2h5l1.5-2h4" />
-	{:else if name === 'library'}
-		<path d="M5 4.5h4v15H5zM10.5 4.5h4v15h-4zM16 5.5l3-1 3.5 14-3 1z" />
-	{:else if name === 'shows'}
-		<path d="M4 6.5h16v13H4zM8 3.5v6M16 3.5v6M4 10h16" />
-	{:else if name === 'archive'}
-		<path d="M4 7h16v13H4zM3 4h18v4H3zM9 12h6" />
-	{:else if name === 'settings'}
-		<circle cx="12" cy="12" r="3" />
-		<path
-			d="M12 3v2M12 19v2M3 12h2M19 12h2M5.6 5.6 7 7M17 17l1.4 1.4M18.4 5.6 17 7M7 17l-1.4 1.4"
-		/>
-	{/if}
-</svg>
 
 <style>
-	svg {
+	:global(.app-icon) {
-		width: 1.25rem;
+		display: block;
-		height: 1.25rem;
-		fill: none;
-		stroke: currentColor;
-		stroke-linecap: round;
-		stroke-linejoin: round;
-		stroke-width: 1.7;
 	}
 </style>

src/lib/components/PieceEditorDialog.svelte

@@ -0,0 +1,82 @@
+<script lang="ts">
+	import { tick, type Snippet } from 'svelte';
+	import AppIcon from './AppIcon.svelte';
+
+	let {
+		labelledby,
+		activeSection = $bindable(),
+		onrequestclose,
+		header,
+		children,
+		footer
+	}: {
+		labelledby: string;
+		activeSection: 'script' | 'research' | 'presentation';
+		onrequestclose: () => void;
+		header: Snippet;
+		children: Snippet;
+		footer: Snippet;
+	} = $props();
+
+	let dialog: HTMLDialogElement;
+	let workspace: HTMLDivElement;
+	const scrollPositions = { script: 0, research: 0, presentation: 0 };
+
+	async function selectSection(section: typeof activeSection) {
+		scrollPositions[activeSection] = workspace.scrollTop;
+		activeSection = section;
+		await tick();
+		workspace.scrollTop = scrollPositions[section];
+	}
+
+	export function showModal() {
+		if (!dialog.open) dialog.showModal();
+	}
+
+	export function close() {
+		dialog.close();
+	}
+</script>
+
+<dialog
+	bind:this={dialog}
+	class="piece-editor-dialog"
+	aria-labelledby={labelledby}
+	oncancel={(event) => {
+		event.preventDefault();
+		onrequestclose();
+	}}
+	onclick={(event) => event.target === dialog && onrequestclose()}
+>
+	<header class="piece-dialog-header">
+		<div class="piece-dialog-heading">{@render header()}</div>
+		<button
+			class="dialog-close"
+			type="button"
+			aria-label="Editor schließen"
+			onclick={onrequestclose}><AppIcon name="xmark" /></button
+		>
+	</header>
+	<nav class="piece-dialog-tabs" aria-label="Editorbereiche">
+		<button
+			type="button"
+			class:active={activeSection === 'script'}
+			aria-current={activeSection === 'script' ? 'page' : undefined}
+			onclick={() => selectSection('script')}>Sendungstext</button
+		>
+		<button
+			type="button"
+			class:active={activeSection === 'research'}
+			aria-current={activeSection === 'research' ? 'page' : undefined}
+			onclick={() => selectSection('research')}>Recherche & Quellen</button
+		>
+		<button
+			type="button"
+			class:active={activeSection === 'presentation'}
+			aria-current={activeSection === 'presentation' ? 'page' : undefined}
+			onclick={() => selectSection('presentation')}>Präsentation</button
+		>
+	</nav>
+	<div bind:this={workspace} class="piece-dialog-workspace">{@render children()}</div>
+	<footer class="piece-dialog-footer">{@render footer()}</footer>
+</dialog>

src/lib/components/PieceUsageHistory.svelte

@@ -0,0 +1,36 @@
+<script lang="ts">
+	import { resolve } from '$app/paths';
+	import type { SentPieceUsage } from '#lib/server/shows.js';
+
+	let { history }: { history: SentPieceUsage[] } = $props();
+
+	function berlinDate(value: string) {
+		return new Intl.DateTimeFormat('de-DE', {
+			timeZone: 'Europe/Berlin',
+			dateStyle: 'medium'
+		}).format(new Date(value));
+	}
+</script>
+
+{#if history.length}
+	<div class="piece-usage-history">
+		<p>
+			<strong>Gesendet am {berlinDate(history[0].usedAtUtc)}</strong>
+			in <a href={resolve('/sendungen/[id]', { id: history[0].showId })}>{history[0].showTitle}</a>
+			{#if history.length > 1}<span>+ {history.length - 1} weitere</span>{/if}
+		</p>
+		{#if history.length > 1}
+			<details>
+				<summary>Vollständige Verwendungshistorie</summary>
+				<ul>
+					{#each history as usage (usage.usageId)}
+						<li>
+							<time datetime={usage.usedAtUtc}>{berlinDate(usage.usedAtUtc)}</time>
+							<a href={resolve('/sendungen/[id]', { id: usage.showId })}>{usage.showTitle}</a>
+						</li>
+					{/each}
+				</ul>
+			</details>
+		{/if}
+	</div>
+{/if}

src/lib/components/PresentationDisplay.svelte

@@ -0,0 +1,115 @@
+<script lang="ts">
+	import { onMount } from 'svelte';
+	import type { PresentationContent } from '#lib/server/presentation.js';
+
+	let {
+		content,
+		imageSrc = ''
+	}: {
+		content: PresentationContent & {
+			sources?: { label: string; url: string }[];
+			images?: { id: string; altText: string }[];
+		};
+		imageSrc?: string;
+	} = $props();
+	let frame = $state<HTMLIFrameElement>();
+	let playerUnavailable = $state(false);
+	let imageUnavailable = $state(false);
+
+	onMount(() => {
+		const receive = (event: MessageEvent) => {
+			if (content.provider !== 'tiktok' || event.origin !== 'https://www.tiktok.com') return;
+			if (event.source !== frame?.contentWindow || typeof event.data !== 'object' || !event.data)
+				return;
+			const message = event.data as { type?: string; value?: unknown };
+			if (message.type === 'onPlayerReady' && content.source?.timecodeSeconds) {
+				frame.contentWindow?.postMessage(
+					{
+						type: 'seekTo',
+						value: content.source.timecodeSeconds,
+						'x-tiktok-player': true
+					},
+					'https://www.tiktok.com'
+				);
+			}
+			if (message.type === 'onPlayerError') playerUnavailable = true;
+		};
+		addEventListener('message', receive);
+		return () => removeEventListener('message', receive);
+	});
+</script>
+
+{#if content.mode === 'text'}
+	<article class="output-content output-text">
+		{#if content.topics.length}<p class="output-topics">{content.topics.join(' · ')}</p>{/if}
+		<h1>{content.title}</h1>
+		<!-- HTML is produced exclusively by the server-side allowlist sanitizer. -->
+		<!-- eslint-disable-next-line svelte/no-at-html-tags -->
+		<div class="output-copy">{@html content.html}</div>
+		{#if content.images?.length}<div class="output-images">
+				{#each content.images as image (image.id)}
+					<img src={`${imageSrc}/${image.id}`} alt={image.altText} />
+				{/each}
+			</div>{/if}
+		{#if content.sources?.length}<footer class="output-sources">
+				<span>Quellen</span>
+				{#each content.sources as source, index (`${index}-${source.url}`)}
+					<!-- The URL is a server-validated external HTTP(S) source. -->
+					<!-- eslint-disable-next-line svelte/no-navigation-without-resolve -->
+					<a href={source.url} target="_blank" rel="noopener noreferrer">{source.label}</a>
+				{/each}
+			</footer>{/if}
+	</article>
+{:else if content.mode === 'link'}
+	<article class="output-content output-link-card">
+		{#if imageSrc && !imageUnavailable}<div class="output-link-image">
+				<img src={imageSrc} alt="" onerror={() => (imageUnavailable = true)} />
+			</div>{/if}
+		<div class="output-link-copy">
+			{#if content.topics.length}<p class="output-topics">{content.topics.join(' · ')}</p>{/if}
+			<p class="output-kicker">{content.siteName || content.source?.label || 'Webseite'}</p>
+			<h1>{content.previewTitle || content.title}</h1>
+			{#if content.description}<p>{content.description}</p>{/if}
+			<!-- The URL is a server-validated external HTTP(S) source. -->
+			<!-- eslint-disable-next-line svelte/no-navigation-without-resolve -->
+			{#if content.source}<a href={content.source.url} target="_blank" rel="noopener noreferrer"
+					>Original öffnen</a
+				>{/if}
+		</div>
+	</article>
+{:else}
+	<article class:portrait={content.provider === 'tiktok'} class="output-content output-video">
+		<header>
+			{#if content.topics.length}<p class="output-topics">{content.topics.join(' · ')}</p>{/if}
+			<p class="output-kicker">{content.siteName || content.source?.label || 'Video'}</p>
+			<h1>{content.previewTitle || content.title}</h1>
+		</header>
+		{#if content.embedUrl && !playerUnavailable}
+			<div class="output-player">
+				<iframe
+					bind:this={frame}
+					title={content.previewTitle || content.title}
+					src={content.embedUrl}
+					allow="encrypted-media; fullscreen; picture-in-picture"
+					allowfullscreen
+					onerror={() => (playerUnavailable = true)}
+				></iframe>
+			</div>
+		{:else}
+			<section class="output-fallback">
+				<strong>Video kann nicht eingebettet werden</strong>
+				<p>Der Anbieter oder diese URL ist für die eingebettete Wiedergabe nicht verfügbar.</p>
+				<!-- The URL is a server-validated external HTTP(S) source. -->
+				<!-- eslint-disable-next-line svelte/no-navigation-without-resolve -->
+				{#if content.source}<a href={content.source.url} target="_blank" rel="noopener noreferrer"
+						>Original öffnen</a
+					>{/if}
+			</section>
+		{/if}
+		{#if content.source}<footer class="output-video-source">
+				<!-- The URL is a server-validated external HTTP(S) source. -->
+				<!-- eslint-disable-next-line svelte/no-navigation-without-resolve -->
+				<a href={content.source.url} target="_blank" rel="noopener noreferrer">Original öffnen</a>
+			</footer>{/if}
+	</article>
+{/if}

src/lib/components/ThemeToggle.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
 	import { onMount } from 'svelte';
+	import AppIcon from './AppIcon.svelte';
 
 	type Preference = 'system' | 'light' | 'dark';
 	const preferences: Preference[] = ['system', 'light', 'dark'];
@@ -42,8 +43,10 @@
 	onclick={cycle}
 	aria-label={`Darstellung: ${labels[preference]}`}
 >
-	<span class="theme-symbol" aria-hidden="true">
+	<span class="theme-symbol" aria-hidden="true"
-		{preference === 'system' ? '◐' : preference === 'light' ? '○' : '●'}
+		><AppIcon
-	</span>
+			name={preference === 'system' ? 'display' : preference === 'light' ? 'sun' : 'moon'}
+		/></span
+	>
 	<span>{labels[preference]}</span>
 </button>

src/lib/components/ToolEditorDialog.svelte

@@ -0,0 +1,125 @@
+<script lang="ts">
+	import { tick } from 'svelte';
+	import AppIcon from './AppIcon.svelte';
+	import ChoicePicker from './ChoicePicker.svelte';
+	import IconPicker from './IconPicker.svelte';
+
+	type Format = { id: string; name: string };
+	type Tool = {
+		id: string;
+		name: string;
+		startUrl: string;
+		description: string;
+		iconName: string;
+		isActive: boolean;
+		formatIds: string[];
+	};
+
+	let { formats }: { formats: Format[] } = $props();
+	let dialog: HTMLDialogElement;
+	let nameInput: HTMLInputElement;
+	let tool = $state<Tool | null>(null);
+	let name = $state('');
+	let startUrl = $state('');
+	let description = $state('');
+	let iconName = $state('wrench');
+	let isActive = $state(true);
+	let formatIds = $state<string[]>([]);
+
+	export async function showModal(selectedTool: Tool | null = null) {
+		tool = selectedTool;
+		name = selectedTool?.name ?? '';
+		startUrl = selectedTool?.startUrl ?? '';
+		description = selectedTool?.description ?? '';
+		iconName = selectedTool?.iconName || 'wrench';
+		isActive = selectedTool?.isActive ?? true;
+		formatIds = [...(selectedTool?.formatIds ?? [])];
+		dialog.showModal();
+		await tick();
+		nameInput.focus();
+	}
+
+	function close() {
+		dialog.close();
+	}
+</script>
+
+<dialog
+	bind:this={dialog}
+	class="management-dialog tool-editor-dialog"
+	aria-labelledby="tool-dialog-title"
+	onclick={(event) => event.target === dialog && close()}
+>
+	<header>
+		<div class="management-dialog-title">
+			<span class="management-dialog-icon"><AppIcon name={iconName || 'wrench'} /></span>
+			<div>
+				<p class="eyebrow">{tool ? 'Werkzeug bearbeiten' : 'Werkzeug hinzufügen'}</p>
+				<h2 id="tool-dialog-title">{tool?.name || 'Neues Werkzeug'}</h2>
+			</div>
+		</div>
+		<button class="dialog-close" type="button" aria-label="Werkzeugdialog schließen" onclick={close}
+			><AppIcon name="xmark" /></button
+		>
+	</header>
+	<form
+		class="management-dialog-form"
+		method="POST"
+		action={tool ? '?/updateTool' : '?/createTool'}
+	>
+		{#if tool}<input type="hidden" name="toolId" value={tool.id} />{/if}
+		<div class="management-dialog-fields">
+			<label
+				>Name<input
+					bind:this={nameInput}
+					bind:value={name}
+					name="name"
+					required
+					maxlength="120"
+				/></label
+			>
+			<label
+				>Start-URL<input
+					bind:value={startUrl}
+					name="startUrl"
+					type="url"
+					maxlength="2000"
+					placeholder="https://…"
+				/></label
+			>
+			<label class="wide-field"
+				>Beschreibung<textarea bind:value={description} name="description" rows="3" maxlength="2000"
+				></textarea></label
+			>
+		</div>
+		<div class="management-dialog-selections">
+			<div>
+				<span class="field-label">Icon</span>
+				<IconPicker bind:name={iconName} />
+			</div>
+			<div>
+				<span class="field-label">Passende Formate</span>
+				<ChoicePicker
+					items={formats}
+					selectedIds={formatIds}
+					label="Formate"
+					fieldName="formatIds"
+					onselectionchange={(ids) => (formatIds = ids)}
+				/>
+			</div>
+			<label class="toggle-row"
+				><input type="checkbox" name="isActive" value="1" bind:checked={isActive} /><span
+					><strong>Aktiv</strong><small
+						>Deaktivierte Werkzeuge bleiben in bestehenden Pieces erhalten.</small
+					></span
+				></label
+			>
+		</div>
+		<footer>
+			<button class="secondary-button" type="button" onclick={close}>Abbrechen</button>
+			<button class="primary-button" type="submit"
+				>{tool ? 'Änderungen speichern' : 'Werkzeug anlegen'}</button
+			>
+		</footer>
+	</form>
+</dialog>

src/lib/components/UsageEditorDialog.svelte

@@ -0,0 +1,406 @@
+<script lang="ts">
+	import { enhance, type SubmitFunction } from '$app/forms';
+	import { untrack } from 'svelte';
+	import MarkdownEditorField from './MarkdownEditorField.svelte';
+	import InlineTitleEditor from './InlineTitleEditor.svelte';
+	import NavIcon from './NavIcon.svelte';
+	import PieceEditorDialog from './PieceEditorDialog.svelte';
+	import type { PieceUsage } from '#lib/server/shows.js';
+
+	let {
+		usage,
+		revision,
+		sectionId,
+		sections,
+		error,
+		enhanceCommand
+	}: {
+		usage: PieceUsage;
+		revision: number;
+		sectionId: string;
+		sections: { id: string; name: string }[];
+		error?: string;
+		enhanceCommand: SubmitFunction;
+	} = $props();
+
+	let formId = $derived(`usage-editor-form-${usage.id}`);
+	let editor: { showModal: () => void; close: () => void };
+	let activeSection = $state<'script' | 'research' | 'presentation'>('script');
+	let draft = $state(
+		untrack(() => ({ ...usage, tools: usage.tools.map((tool) => ({ ...tool })) }))
+	);
+	let dirty = $state(false);
+	let selectedMedia = $derived(
+		draft.media.find((media) => media.id === draft.presentationMediaId) ?? null
+	);
+
+	function durationInMinutes(seconds: number) {
+		return Number((seconds / 60).toFixed(2));
+	}
+
+	function requestClose() {
+		if (dirty && !confirm('Ungespeicherte Änderungen verwerfen und Editor schließen?')) return;
+		dirty = false;
+		editor.close();
+	}
+
+	const enhanceEditor: SubmitFunction = async (input) => {
+		const finish = await enhanceCommand(input);
+		return async (result) => {
+			if (finish) await finish(result);
+			if (result.result.type === 'success') dirty = false;
+		};
+	};
+</script>
+
+<button
+	class="usage-edit-button"
+	type="button"
+	aria-label={`${usage.title} bearbeiten und verschieben`}
+	title="Bearbeiten und verschieben"
+	onclick={() => editor.showModal()}
+>
+	<NavIcon name="edit" />
+</button>
+
+<PieceEditorDialog
+	bind:this={editor}
+	bind:activeSection
+	labelledby={`usage-editor-title-${usage.id}`}
+	onrequestclose={requestClose}
+>
+	{#snippet header()}
+		<p class="eyebrow">Sendungsfassung</p>
+		<InlineTitleEditor form={formId} bind:value={draft.title} oncommit={() => (dirty = true)} />
+		<h2 class="sr-only" id={`usage-editor-title-${usage.id}`}>{draft.title}</h2>
+	{/snippet}
+
+	<form
+		id={formId}
+		use:enhance={enhanceEditor}
+		method="POST"
+		action="?/updateUsage"
+		class="piece-dialog-form"
+		oninput={() => (dirty = true)}
+		onchange={() => (dirty = true)}
+	>
+		<input type="hidden" name="revision" value={revision} />
+		<input type="hidden" name="usageId" value={usage.id} />
+
+		<section class="piece-editor-panel" hidden={activeSection !== 'script'}>
+			<div class="piece-panel-heading">
+				<div>
+					<p class="eyebrow">Für die Moderation</p>
+					<h3>Sendungstext</h3>
+				</div>
+			</div>
+			<div class="piece-writing-stack">
+				<MarkdownEditorField
+					name="intro"
+					label="Einleitung"
+					placeholder="Wie beginnt dieses Thema in der Sendung?"
+					bind:value={draft.intro}
+				/>
+				<MarkdownEditorField
+					name="moderation"
+					label="Moderationsstichpunkte"
+					placeholder="Argumente, Fragen und Ablaufpunkte"
+					rows={10}
+					bind:value={draft.moderation}
+				/>
+				<MarkdownEditorField
+					name="transition"
+					label="Überleitung"
+					placeholder="Wie geht es zum nächsten Thema weiter?"
+					bind:value={draft.transition}
+				/>
+			</div>
+			<details class="piece-meta-details">
+				<summary>Dauer und Einplanung</summary>
+				<div class="piece-meta-grid">
+					<label
+						>Dauer in Minuten<input
+							name="durationMinutes"
+							type="number"
+							min="0"
+							max="1440"
+							step="any"
+							value={durationInMinutes(usage.durationSeconds)}
+						/></label
+					>
+				</div>
+			</details>
+		</section>
+
+		<section class="piece-editor-panel" hidden={activeSection !== 'research'}>
+			<div class="piece-panel-heading">
+				<div>
+					<p class="eyebrow">Nicht öffentlich</p>
+					<h3>Recherche & Quellen</h3>
+				</div>
+				<small>Diese Inhalte bleiben innerhalb der Redaktion.</small>
+			</div>
+			<div class="piece-writing-stack">
+				<MarkdownEditorField
+					name="research"
+					label="Private Recherche"
+					placeholder="Hintergrund, Prüfung und offene Fragen"
+					rows={10}
+					privateField
+					bind:value={draft.research}
+				/>
+				<MarkdownEditorField
+					name="ownNotes"
+					label="Interne Notizen zu dieser Verwendung"
+					placeholder="Absprachen und Hinweise nur für diese Sendung"
+					privateField
+					bind:value={draft.ownNotes}
+				/>
+			</div>
+			<section class="piece-source-summary">
+				<p class="eyebrow">Snapshot-Quellen</p>
+				{#if draft.sources.length}
+					{#each draft.sources as source (source.id)}<div>
+							<strong>{source.label}</strong><small>{source.url}</small>
+						</div>{/each}
+				{:else}<p>Für diese Verwendung wurden keine Quellen kopiert.</p>{/if}
+			</section>
+			<section class="piece-source-editor">
+				<div class="piece-subsection-heading">
+					<div>
+						<p class="eyebrow">Snapshot</p>
+						<h3>Werkzeuge</h3>
+					</div>
+					<small>Name und Start-URL bleiben Teil der Sendungsfassung.</small>
+				</div>
+				{#if draft.tools.length}<div class="source-list">
+						{#each draft.tools as tool (tool.id)}<div class="source-row tool-assignment-row">
+								<input type="hidden" name="usageToolId" value={tool.id} />
+								<div class="tool-assignment-name">
+									<strong>{tool.name}</strong>{#if tool.startUrl}<small>{tool.startUrl}</small>{/if}
+								</div>
+								<label
+									>Arbeitslink<input
+										name="toolWorkUrl"
+										type="url"
+										maxlength="2000"
+										placeholder={tool.startUrl || 'https://…'}
+										bind:value={tool.workUrl}
+									/></label
+								>
+								<label>Notiz<input name="toolNote" maxlength="2000" bind:value={tool.note} /></label
+								>
+							</div>{/each}
+					</div>{:else}<p class="context-empty">Keine Werkzeuge in dieser Sendungsfassung.</p>{/if}
+			</section>
+		</section>
+
+		<section class="piece-editor-panel" hidden={activeSection !== 'presentation'}>
+			<div class="piece-panel-heading">
+				<div>
+					<p class="eyebrow">Öffentliche Ausgabe</p>
+					<h3>Präsentation</h3>
+				</div>
+				<small>Private Recherche und Notizen werden nicht ausgegeben.</small>
+			</div>
+			<div class="piece-presentation-layout">
+				<div class="piece-presentation-controls">
+					<label
+						>Präsentationstitel<input
+							name="outputTitle"
+							maxlength="300"
+							placeholder="Optional, sonst interner Titel"
+							bind:value={draft.outputTitle}
+						/></label
+					>
+					<MarkdownEditorField
+						name="presentation"
+						label="Öffentlicher Text"
+						placeholder="Text für die Publikumsausgabe"
+						bind:value={draft.presentation}
+					/>
+					<div class="presentation-mode-picker" role="group" aria-label="Darstellung">
+						{#each [['text', 'Text'], ['link', 'Linkvorschau'], ['video', 'Video']] as mode (mode[0])}
+							<label
+								><input
+									type="radio"
+									name="presentationMode"
+									value={mode[0]}
+									bind:group={draft.presentationMode}
+								/>{mode[1]}</label
+							>
+						{/each}
+					</div>
+					<input
+						type="hidden"
+						name="presentationSourceLabel"
+						value={draft.presentationSourceLabel}
+					/>
+					<input type="hidden" name="presentationSourceUrl" value={draft.presentationSourceUrl} />
+					<input
+						type="hidden"
+						name="presentationSourceTimecodeSeconds"
+						value={draft.presentationSourceTimecodeSeconds ?? ''}
+					/>
+					<input type="hidden" name="presentationSiteName" value={draft.presentationSiteName} />
+					<input type="hidden" name="presentationMediaId" value={draft.presentationMediaId ?? ''} />
+					{#if draft.presentationMode !== 'text'}
+						<div class="presentation-settings">
+							<div class="presentation-source-summary wide-field">
+								<span>Ausgewählte Quelle</span>
+								<strong
+									>{draft.presentationSourceLabel ||
+										draft.presentationSourceUrl ||
+										'Keine Quelle'}</strong
+								>
+								{#if draft.presentationSourceUrl}<small>{draft.presentationSourceUrl}</small>{/if}
+							</div>
+							<label
+								>Kartentitel<input
+									name="presentationTitle"
+									maxlength="300"
+									placeholder="Optionaler Anzeigetitel"
+									bind:value={draft.presentationTitle}
+								/></label
+							>
+							<label
+								>Bild-URL<input
+									name="presentationImageUrl"
+									type="url"
+									maxlength="2000"
+									placeholder="https://…"
+									bind:value={draft.presentationImageUrl}
+								/></label
+							>
+							<label class="wide-field"
+								>Anreißer<textarea
+									name="presentationDescription"
+									rows="3"
+									maxlength="1000"
+									placeholder="Kurzer Text zur Vorschau"
+									bind:value={draft.presentationDescription}></textarea></label
+							>
+						</div>
+					{:else}
+						<input type="hidden" name="presentationTitle" value={draft.presentationTitle} />
+						<input
+							type="hidden"
+							name="presentationDescription"
+							value={draft.presentationDescription}
+						/>
+						<input type="hidden" name="presentationImageUrl" value={draft.presentationImageUrl} />
+					{/if}
+				</div>
+				{#if draft.media.length}<fieldset class="usage-media-picker">
+						<legend>Hochgeladenes Präsentationsbild</legend>
+						<label
+							><input
+								type="radio"
+								checked={!draft.presentationMediaId}
+								onchange={() => {
+									draft.presentationMediaId = null;
+									dirty = true;
+								}}
+							/> Kein Bild</label
+						>
+						<div class="media-grid">
+							{#each draft.media as media (media.id)}<label class="media-presentation-choice"
+									><input
+										type="radio"
+										checked={draft.presentationMediaId === media.id}
+										onchange={() => {
+											draft.presentationMediaId = media.id;
+											dirty = true;
+										}}
+									/><img src={`/media/${media.originalMediaId}`} alt={media.altText} /><span
+										>Auswählen</span
+									></label
+								>{/each}
+						</div>
+					</fieldset>{/if}
+				<aside class="piece-presentation-preview" aria-label="Präsentationsvorschau">
+					<p class="output-kicker">Vorschau · {draft.presentationMode}</p>
+					<h4>{draft.outputTitle || draft.title}</h4>
+					{#if draft.presentationMode === 'text'}
+						<p class="preview-markdown-source">
+							{draft.presentation || 'Noch kein öffentlicher Text.'}
+						</p>
+						{#if selectedMedia}<img
+								src={`/media/${selectedMedia.originalMediaId}`}
+								alt={selectedMedia.altText}
+							/>{/if}
+					{:else}
+						{#if selectedMedia}<img
+								src={`/media/${selectedMedia.originalMediaId}`}
+								alt={selectedMedia.altText}
+							/>{:else if draft.presentationImageUrl}<img
+								src={draft.presentationImageUrl}
+								alt=""
+							/>{/if}
+						<p>
+							{draft.presentationDescription ||
+								draft.presentationSourceUrl ||
+								'Noch keine Vorschauangaben.'}
+						</p>
+					{/if}
+				</aside>
+			</div>
+		</section>
+	</form>
+
+	{#snippet footer()}
+		<div class="piece-dialog-secondary-actions">
+			<form use:enhance={enhanceCommand} method="POST" action="?/refreshUsage">
+				<input type="hidden" name="revision" value={revision} />
+				<input type="hidden" name="usageId" value={usage.id} />
+				<button class="text-button" type="submit" disabled={!usage.originalPieceId || dirty}
+					>Aus Fundus aktualisieren</button
+				>
+			</form>
+			<form use:enhance={enhanceCommand} method="POST" action="?/duplicateUsage">
+				<input type="hidden" name="revision" value={revision} /><input
+					type="hidden"
+					name="usageId"
+					value={usage.id}
+				/>
+				<button class="text-button" type="submit" disabled={dirty}>Duplizieren</button>
+			</form>
+			<form use:enhance={enhanceCommand} method="POST" action="?/moveUsage">
+				<input type="hidden" name="revision" value={revision} /><input
+					type="hidden"
+					name="usageId"
+					value={usage.id}
+				/><input type="hidden" name="position" value="9999" />
+				<label
+					><span class="sr-only">Ziel</span><select name="sectionId"
+						><option value="">Reservebank</option>{#each sections as target (target.id)}<option
+								value={target.id}
+								selected={target.id === sectionId}>{target.name}</option
+							>{/each}</select
+					></label
+				>
+				<button class="text-button" type="submit" disabled={dirty}>Verschieben</button>
+			</form>
+			<form
+				use:enhance={enhanceCommand}
+				method="POST"
+				action="?/removeUsage"
+				onsubmit={(event) =>
+					!confirm('Piece aus dieser Sendung entfernen?') && event.preventDefault()}
+			>
+				<input type="hidden" name="revision" value={revision} /><input
+					type="hidden"
+					name="usageId"
+					value={usage.id}
+				/>
+				<button class="text-button danger-text" type="submit" disabled={dirty}
+					>Aus Sendung entfernen</button
+				>
+			</form>
+		</div>
+		<div class="piece-dialog-primary-action">
+			{#if error}<span class="problem" role="alert">{error}</span>{/if}
+			<button class="primary-button" type="submit" form={formId}>Verwendung speichern</button>
+		</div>
+	{/snippet}
+</PieceEditorDialog>

src/lib/server/content.spec.ts

@@ -12,13 +12,19 @@ import {
 	getMediaFile,
 	getPiece,
 	getTaxonomy,
+	listPieceTemplates,
 	listPieces,
+	loadPiecePresentationMetadata,
 	savePiece,
+	savePieceAsTemplate,
 	setPieceArchived,
+	setPieceDeleted,
+	setPieceFavorite,
 	uploadPieceImage,
+	updateTaxonomy,
 	type PieceInput
 } from './content.js';
-import { closeDatabase } from './database.js';
+import { closeDatabase, getDatabase } from './database.js';
 import { renderMarkdown } from './markdown.js';
 
 let directory: string;
@@ -41,6 +47,7 @@ afterEach(() => {
 function completeInput(overrides: Partial<PieceInput> = {}): PieceInput {
 	return {
 		title: 'Getestetes Piece',
+		outputTitle: '',
 		summary: 'Eine persistente Kurzbeschreibung.',
 		formatId: 'format-talk',
 		status: 'ready',
@@ -50,6 +57,18 @@ function completeInput(overrides: Partial<PieceInput> = {}): PieceInput {
 		moderationNotes: '- Punkt eins',
 		transitionText: 'Weiter geht es.',
 		presentationText: '## Sichtbare Aussage',
+		presentationMode: 'text',
+		presentationSourcePosition: null,
+		presentationTitle: '',
+		presentationDescription: '',
+		presentationImageUrl: '',
+		presentationSiteName: '',
+		presentationProvider: '',
+		presentationProviderId: '',
+		presentationTitleManual: false,
+		presentationDescriptionManual: false,
+		presentationImageManual: false,
+		presentationMetadataFetchedAtUtc: null,
 		topicIds: ['topic-gaming', 'topic-internet'],
 		categoryIds: ['cat-jc', 'cat-reaction'],
 		sources: [
@@ -60,6 +79,57 @@ function completeInput(overrides: Partial<PieceInput> = {}): PieceInput {
 }
 
 describe('content management', () => {
+	it('sorts global favorites first without changing their revision', () => {
+		const before = getPiece('piece-console')!;
+		setPieceFavorite('piece-console', true);
+		const pieces = listPieces({ statuses: ['ready'] });
+		expect(pieces[0]).toMatchObject({ id: 'piece-console', isFavorite: true });
+		expect(getPiece('piece-console')).toMatchObject({
+			isFavorite: true,
+			revision: before.revision,
+			status: before.status
+		});
+	});
+
+	it('persists independently versioned templates and copies their complete snapshot', () => {
+		const sourceId = createPiece('talk');
+		const source = getPiece(sourceId)!;
+		savePiece(
+			sourceId,
+			source.revision,
+			completeInput({
+				title: 'Interner Vorlagentitel',
+				outputTitle: 'Titel für die Ausgabe',
+				presentationText: 'Unveränderlicher Vorlagentext'
+			})
+		);
+		const created = savePieceAsTemplate(sourceId, 'Eigene Vorlage', 'Redaktioneller Stand');
+		const template = listPieceTemplates().find((entry) => entry.id === created.id)!;
+		expect(template).toMatchObject({ name: 'Eigene Vorlage', revision: 1 });
+
+		const changed = getPiece(sourceId)!;
+		savePiece(sourceId, changed.revision, {
+			...changed,
+			status: 'ready',
+			presentationText: 'Spätere Änderung'
+		});
+		const copyId = createPiece(created.id);
+		expect(getPiece(copyId)).toMatchObject({
+			title: 'Interner Vorlagentitel',
+			outputTitle: 'Titel für die Ausgabe',
+			presentationText: 'Unveränderlicher Vorlagentext',
+			sources: [
+				{ label: 'Dokumentation', url: 'https://example.com/dokumentation', timecodeSeconds: 75 }
+			]
+		});
+
+		const updated = savePieceAsTemplate(sourceId, 'Eigene Vorlage', 'Neuer Stand', created.id, 1);
+		expect(updated.revision).toBe(2);
+		expect(() =>
+			savePieceAsTemplate(sourceId, 'Eigene Vorlage', 'Veraltet', created.id, 1)
+		).toThrow('CONFLICT');
+	});
+
 	it('persists complete pieces and rejects stale revisions atomically', () => {
 		const id = createPiece('talk');
 		const initial = getPiece(id)!;
@@ -86,9 +156,61 @@ describe('content management', () => {
 		});
 	});
 
+	it('stores fetched preview metadata and preserves manual corrections on reload', async () => {
+		const id = createPiece('find');
+		const initial = getPiece(id)!;
+		const saved = savePiece(
+			id,
+			initial.revision,
+			completeInput({
+				presentationMode: 'link',
+				presentationSourcePosition: 0,
+				presentationTitle: 'Manueller Titel',
+				presentationTitleManual: true
+			})
+		);
+		const loaded = await loadPiecePresentationMetadata(id, saved.revision, async () => ({
+			title: 'Automatischer Titel',
+			description: 'Geladener Anreißer',
+			imageUrl: 'https://example.com/vorschau.jpg',
+			siteName: 'Example',
+			provider: '',
+			providerId: ''
+		}));
+		expect(getPiece(id)).toMatchObject({
+			revision: loaded.revision,
+			presentationTitle: 'Manueller Titel',
+			presentationDescription: 'Geladener Anreißer',
+			presentationImageUrl: 'https://example.com/vorschau.jpg',
+			presentationSiteName: 'Example'
+		});
+
+		await loadPiecePresentationMetadata(id, loaded.revision, async () => ({
+			title: 'Anderer automatischer Titel',
+			description: 'Aktualisierter Anreißer',
+			imageUrl: '',
+			siteName: 'Example',
+			provider: '',
+			providerId: ''
+		}));
+		expect(getPiece(id)).toMatchObject({
+			presentationTitle: 'Manueller Titel',
+			presentationDescription: 'Aktualisierter Anreißer'
+		});
+	});
+
 	it('searches independent taxonomies and archives, restores and duplicates pieces', async () => {
-		createTaxonomy('topic', 'Technikgeschichte');
+		createTaxonomy('topic', 'Technikgeschichte', 'microchip');
 		const topic = getTaxonomy().topics.find((entry) => entry.name === 'Technikgeschichte')!;
+		expect(topic.iconName).toBe('microchip');
+		updateTaxonomy('topic', topic.id, 'Computergeschichte', 'microchip');
+		expect(getTaxonomy().topics.find((entry) => entry.id === topic.id)).toMatchObject({
+			name: 'Computergeschichte',
+			iconName: 'microchip'
+		});
+		expect(() => updateTaxonomy('topic', topic.id, 'Computergeschichte', '../unsafe')).toThrow(
+			'INVALID_ICON'
+		);
 		const sourceId = createPiece('find');
 		const source = getPiece(sourceId)!;
 		savePiece(
@@ -142,15 +264,17 @@ describe('content management', () => {
 			'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
 			'base64'
 		);
-		await uploadPieceImage(
+		const uploaded = await uploadPieceImage(
 			id,
 			1,
 			new File([png], '../bild.png', { type: 'text/html' }),
-			'Ein heller Pixel'
+			'Ein heller Pixel',
+			true
 		);
 		const piece = getPiece(id)!;
 		expect(piece.media).toHaveLength(1);
 		expect(piece.media[0]).toMatchObject({ mimeType: 'image/png', altText: 'Ein heller Pixel' });
+		expect(piece.presentationMediaId).toBe(uploaded.id);
 		const media = await getMediaFile(piece.media[0].id);
 		expect(media?.data.equals(png)).toBe(true);
 		expect(existsSync(path.join(directory, 'uploads', '../bild.png'))).toBe(false);
@@ -163,7 +287,87 @@ describe('content management', () => {
 				''
 			)
 		).rejects.toThrow('INVALID_IMAGE_TYPE');
+		const stored = getDatabase()
+			.prepare('SELECT storage_name FROM piece_media WHERE id = ?')
+			.get(piece.media[0].id) as { storage_name: string };
 		await deletePieceImage(id, piece.media[0].id, piece.revision);
 		expect(getPiece(id)?.media).toHaveLength(0);
+		expect(getPiece(id)?.presentationMediaId).toBeNull();
+		expect(await getMediaFile(piece.media[0].id)).toBeNull();
+		expect(existsSync(path.join(directory, 'uploads', stored.storage_name))).toBe(true);
+	});
+
+	it('selects presentation media atomically, copies active media and omits media from templates', async () => {
+		const id = createPiece();
+		const png = Buffer.from(
+			'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
+			'base64'
+		);
+		const selected = await uploadPieceImage(
+			id,
+			1,
+			new File([png], 'auswahl.png', { type: 'image/png' }),
+			'Auswahl',
+			true
+		);
+		const second = await uploadPieceImage(
+			id,
+			selected.revision,
+			new File([png], 'entfernt.png', { type: 'image/png' }),
+			'Entfernt'
+		);
+		await deletePieceImage(id, second.id, second.revision);
+		const source = getPiece(id)!;
+		expect(() =>
+			savePiece(id, source.revision, {
+				...source,
+				title: 'Darf nicht gespeichert werden',
+				status: 'preparing',
+				presentationMediaId: 'fremdes-medium'
+			})
+		).toThrow('presentation media does not belong to piece');
+		expect(getPiece(id)).toMatchObject({
+			title: 'Neues Piece',
+			revision: source.revision,
+			presentationMediaId: selected.id
+		});
+
+		const duplicateId = await duplicatePiece(id);
+		const duplicate = getPiece(duplicateId)!;
+		expect(duplicate.media).toHaveLength(1);
+		expect(duplicate.presentationMediaId).toBe(duplicate.media[0].id);
+		expect(duplicate.presentationMediaId).not.toBe(selected.id);
+
+		const template = savePieceAsTemplate(id, 'Ohne Medienreferenz', 'Nur Inhaltsdaten');
+		const snapshot = getDatabase()
+			.prepare('SELECT snapshot_json FROM piece_templates WHERE id = ?')
+			.get(template.id) as { snapshot_json: string };
+		expect(JSON.parse(snapshot.snapshot_json)).not.toHaveProperty('presentationMediaId');
+		expect(getPiece(createPiece(template.id))?.presentationMediaId).toBeNull();
+	});
+
+	it('soft-deletes pieces behind revisions and keeps their original media private', async () => {
+		const id = createPiece();
+		const png = Buffer.from(
+			'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
+			'base64'
+		);
+		const uploaded = await uploadPieceImage(
+			id,
+			1,
+			new File([png], 'privat.png', { type: 'image/png' }),
+			'Privat'
+		);
+		const deleted = setPieceDeleted(id, uploaded.revision, true);
+		expect(getPiece(id)).toBeNull();
+		expect(listPieces({ statuses: ['preparing'] }).some((piece) => piece.id === id)).toBe(false);
+		expect(await getMediaFile(uploaded.id)).toBeNull();
+		expect(() => setPieceFavorite(id, true)).toThrow('NOT_FOUND');
+		expect(() => savePiece(id, deleted.revision, completeInput())).toThrow('NOT_FOUND');
+		expect(() => setPieceDeleted(id, uploaded.revision, false)).toThrow('CONFLICT');
+
+		const restored = setPieceDeleted(id, deleted.revision, false);
+		expect(getPiece(id)).toMatchObject({ id, revision: restored.revision });
+		expect((await getMediaFile(uploaded.id))?.data.equals(png)).toBe(true);
 	});
 });

src/lib/server/database.spec.ts

@@ -62,7 +62,7 @@ describe('database setup', () => {
 		database.close();
 
 		expect(counts).toEqual({
-			migrations: 4,
+			migrations: 11,
 			pieces: 6,
 			shows: 2,
 			usages: 5,

src/lib/server/live.spec.ts

@@ -0,0 +1,299 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { closeDatabase, getDatabase } from './database.js';
+import {
+	completeCurrent,
+	clearPresentationChannel,
+	getPresentationChannelView,
+	getLiveView,
+	getPresentationMedia,
+	getPresentationView,
+	goBack,
+	issuePresentationAccess,
+	moveOpenUsage,
+	presentationChannelAccess,
+	presentUsage,
+	rotatePresentationChannelKey,
+	selectUsage,
+	skipCurrent,
+	startOrResumeLive
+} from './live.js';
+
+let directory: string;
+
+beforeEach(() => {
+	directory = mkdtempSync(path.join(tmpdir(), 'sendewerk-live-test-'));
+	process.env.SENDEWERK_DB_PATH = path.join(directory, 'test.sqlite');
+	process.env.SENDEWERK_UPLOAD_DIR = path.join(directory, 'uploads');
+	execFileSync(process.execPath, ['scripts/migrate.mjs'], { cwd: process.cwd(), env: process.env });
+	execFileSync(process.execPath, ['scripts/seed.mjs'], { cwd: process.cwd(), env: process.env });
+});
+
+afterEach(() => {
+	closeDatabase();
+	delete process.env.SENDEWERK_DB_PATH;
+	delete process.env.SENDEWERK_UPLOAD_DIR;
+	rmSync(directory, { recursive: true, force: true });
+});
+
+describe('live mode', () => {
+	it('persists a frozen section countdown across usage changes and reloads', () => {
+		getDatabase()
+			.prepare(
+				"UPDATE show_sections SET explicit_duration_seconds = 300 WHERE id = 'section-stories'"
+			)
+			.run();
+		const start = new Date('2026-10-23T18:00:00.000Z');
+		startOrResumeLive('show-october', 'timer-start', 0, start);
+		let live = getLiveView('show-october', new Date('2026-10-23T18:01:40.000Z'));
+		expect(live.sectionTimer).toMatchObject({
+			sectionId: 'section-stories',
+			plannedDurationSeconds: 300,
+			elapsedSeconds: 100
+		});
+		getDatabase()
+			.prepare(
+				"UPDATE show_sections SET explicit_duration_seconds = 600 WHERE id = 'section-stories'"
+			)
+			.run();
+		completeCurrent(
+			'show-october',
+			'timer-next-piece',
+			live.liveRevision,
+			new Date('2026-10-23T18:02:00.000Z')
+		);
+		live = getLiveView('show-october', new Date('2026-10-23T18:04:00.000Z'));
+		expect(live.current?.id).toBe('usage-effects');
+		expect(live.sectionTimer).toMatchObject({
+			plannedDurationSeconds: 300,
+			elapsedSeconds: 240
+		});
+		completeCurrent(
+			'show-october',
+			'timer-finish',
+			live.liveRevision,
+			new Date('2026-10-23T18:06:00.000Z')
+		);
+		expect(
+			getLiveView('show-october', new Date('2026-10-23T18:07:00.000Z')).sectionTimer
+		).toBeNull();
+	});
+
+	it('selects any rundown usage by stable id, including the first and completed entries', () => {
+		let live = getLiveView('show-october');
+		expect(() =>
+			selectUsage('show-october', 'usage-effects', 'select-before-start', live.liveRevision)
+		).toThrow('NOT_STARTED');
+		startOrResumeLive('show-october', 'start-selection', live.liveRevision);
+		live = getLiveView('show-october');
+		selectUsage('show-october', 'usage-effects', 'select-second', live.liveRevision);
+		live = getLiveView('show-october');
+		expect(live.current?.id).toBe('usage-effects');
+
+		selectUsage('show-october', 'usage-console', 'select-first', live.liveRevision);
+		live = getLiveView('show-october');
+		expect(live.current?.id).toBe('usage-console');
+		completeCurrent('show-october', 'complete-first', live.liveRevision);
+		live = getLiveView('show-october');
+		expect(
+			live.sections
+				.flatMap((section) => section.usages)
+				.find((usage) => usage.id === 'usage-console')?.status
+		).toBe('done');
+
+		selectUsage('show-october', 'usage-console', 'return-to-completed', live.liveRevision);
+		expect(getLiveView('show-october').current).toMatchObject({
+			id: 'usage-console',
+			status: 'current'
+		});
+	});
+
+	it('keeps one stable output channel until its key is explicitly rotated', () => {
+		const key = issuePresentationAccess('show-october');
+		expect(issuePresentationAccess('show-october')).toBe(key);
+		expect(presentationChannelAccess('default', key)).toBe(true);
+		expect(getPresentationChannelView('default')).toEqual({
+			revision: 1_000_000_000,
+			content: null
+		});
+
+		const replacement = rotatePresentationChannelKey('show-october');
+		expect(replacement).not.toBe(key);
+		expect(presentationChannelAccess('default', key)).toBe(false);
+		expect(presentationChannelAccess('default', replacement)).toBe(true);
+		startOrResumeLive('show-october', 'start-channel', 0);
+		presentUsage('show-october', 'usage-console', 'present-channel', 1);
+		expect(getPresentationChannelView('default')?.content).not.toBeNull();
+		clearPresentationChannel();
+		expect(getPresentationChannelView('default')?.content).toBeNull();
+		issuePresentationAccess('show-october');
+		expect(getPresentationChannelView('default')?.content).toBeNull();
+	});
+
+	it('restores live state, records actual intervals and applies commands only once', () => {
+		const started = new Date('2026-10-22T18:00:00.000Z');
+		const initial = getLiveView('show-october', started);
+		expect(initial.current).toBeNull();
+
+		expect(startOrResumeLive('show-october', 'start-command', 0, started)).toEqual({
+			revision: 1,
+			duplicate: false
+		});
+		expect(startOrResumeLive('show-october', 'start-command', 0, started)).toEqual({
+			revision: 1,
+			duplicate: true
+		});
+		let live = getLiveView('show-october', new Date('2026-10-22T18:05:00.000Z'));
+		expect(live.current?.id).toBe('usage-console');
+		expect(live.current?.actualDurationSeconds).toBe(300);
+		expect(() =>
+			moveOpenUsage('show-october', 'usage-effects', live.show.revision, {
+				sectionId: 'section-stories',
+				position: 0
+			})
+		).toThrow('LIVE_ORDER_LOCKED');
+
+		completeCurrent('show-october', 'complete-console', 1, new Date('2026-10-22T18:05:00.000Z'));
+		completeCurrent('show-october', 'complete-console', 1, new Date('2026-10-22T18:05:00.000Z'));
+		live = getLiveView('show-october', new Date('2026-10-22T18:06:00.000Z'));
+		expect(live.current?.id).toBe('usage-effects');
+		expect(
+			live.sections
+				.flatMap((section) => section.usages)
+				.find((usage) => usage.id === 'usage-console')
+		).toMatchObject({ status: 'done', actualDurationSeconds: 300 });
+		expect(
+			getDatabase()
+				.prepare('SELECT count(*) AS count FROM live_usage_runs WHERE usage_id = ?')
+				.get('usage-console')
+		).toEqual({ count: 1 });
+
+		expect(() => skipCurrent('show-october', 'stale-command', 1)).toThrow('CONFLICT');
+		skipCurrent('show-october', 'skip-effects', 2, new Date('2026-10-22T18:06:00.000Z'));
+		live = getLiveView('show-october', new Date('2026-10-22T18:07:00.000Z'));
+		expect(live.current).toBeNull();
+		expect(live.completedCount).toBe(2);
+
+		goBack('show-october', 'back-effects', 3, new Date('2026-10-22T18:07:00.000Z'));
+		live = getLiveView('show-october', new Date('2026-10-22T18:08:00.000Z'));
+		expect(live.current).toMatchObject({ id: 'usage-effects', status: 'current' });
+		expect(live.current?.actualDurationSeconds).toBe(120);
+	});
+
+	it('changes presentation only explicitly and exposes no private fields', async () => {
+		const uploads = process.env.SENDEWERK_UPLOAD_DIR!;
+		mkdirSync(uploads, { recursive: true });
+		writeFileSync(path.join(uploads, 'presentation.png'), Buffer.from('test-image'));
+		getDatabase()
+			.prepare(
+				`INSERT INTO piece_media (id, piece_id, storage_name, original_name, mime_type,
+				 byte_size, alt_text, position, created_at_utc) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+			)
+			.run(
+				'presentation-image',
+				'piece-console',
+				'presentation.png',
+				'private-original-name.png',
+				'image/png',
+				10,
+				'Konsole auf dem Tisch',
+				0,
+				'2026-10-22T18:00:00.000Z'
+			);
+		getDatabase()
+			.prepare(
+				`INSERT INTO usage_tool_snapshots
+				 (id, usage_id, original_tool_id, name, start_url, work_url, note, position)
+				 VALUES ('private-live-tool', 'usage-console', NULL, 'Privates Werkzeug', '',
+				 'https://private.example.test/board', 'PRIVATE_TOOL_NOTE', 0)`
+			)
+			.run();
+
+		const token = issuePresentationAccess('show-october');
+		expect(getPresentationView(token)).toEqual({ revision: 0, content: null });
+		startOrResumeLive('show-october', 'start-output', 0);
+		expect(getPresentationView(token)).toEqual({ revision: 0, content: null });
+
+		presentUsage('show-october', 'usage-console', 'present-console', 1);
+		const output = getPresentationView(token)!;
+		expect(output.content).toMatchObject({
+			title: 'Die kleine Konsole mit dem großen Dreh',
+			topics: ['Gaming'],
+			images: [],
+			sources: []
+		});
+		const serialized = JSON.stringify(output);
+		expect(serialized).toContain('Weniger Leistung, mehr Idee.');
+		expect(serialized).not.toContain('Herstellerangaben');
+		expect(serialized).not.toContain('Moderationsstichpunkte');
+		expect(serialized).not.toContain('private-original-name');
+		expect(serialized).not.toContain('presentation.png');
+		expect(serialized).not.toContain('https://example.com/console');
+		expect(serialized).not.toContain('https://private.example.test/board');
+		expect(serialized).not.toContain('PRIVATE_TOOL_NOTE');
+
+		const media = await getPresentationMedia(token, 'presentation-image');
+		expect(media).toBeNull();
+		expect(await getPresentationMedia(token, 'unknown-image')).toBeNull();
+
+		const replacementToken = issuePresentationAccess('show-october');
+		expect(replacementToken).toBe(token);
+		expect(getPresentationView(token)?.content?.title).toBe(
+			'Die kleine Konsole mit dem großen Dreh'
+		);
+		expect(getPresentationView(replacementToken)?.content?.title).toBe(
+			'Die kleine Konsole mit dem großen Dreh'
+		);
+	});
+
+	it('projects only snapshotted link and video data and changes players explicitly', () => {
+		getDatabase()
+			.prepare(
+				`UPDATE piece_usages SET presentation_mode_snapshot = 'video',
+				 presentation_source_label_snapshot = 'YouTube',
+				 presentation_source_url_snapshot = 'https://youtu.be/dQw4w9WgXcQ',
+				 presentation_source_timecode_snapshot = 75,
+				 presentation_title_meta_snapshot = 'Videotitel',
+				 presentation_site_name_snapshot = 'YouTube',
+				 presentation_provider_snapshot = 'youtube',
+				 presentation_provider_id_snapshot = 'dQw4w9WgXcQ'
+				 WHERE id = 'usage-console'`
+			)
+			.run();
+		getDatabase()
+			.prepare(
+				`UPDATE piece_usages SET presentation_mode_snapshot = 'link',
+				 presentation_source_label_snapshot = 'Artikel',
+				 presentation_source_url_snapshot = 'https://example.com/artikel',
+				 presentation_title_meta_snapshot = 'Linktitel',
+				 presentation_description_snapshot = 'Öffentlicher Anreißer',
+				 presentation_site_name_snapshot = 'Example'
+				 WHERE id = 'usage-effects'`
+			)
+			.run();
+		const token = issuePresentationAccess('show-october');
+		presentUsage('show-october', 'usage-console', 'present-video', 0);
+		expect(getPresentationView(token)?.content).toMatchObject({
+			mode: 'video',
+			previewTitle: 'Videotitel',
+			embedUrl: 'https://www.youtube-nocookie.com/embed/dQw4w9WgXcQ?start=75',
+			source: { url: 'https://youtu.be/dQw4w9WgXcQ', timecodeSeconds: 75 }
+		});
+
+		presentUsage('show-october', 'usage-effects', 'present-link', 1);
+		const link = getPresentationView(token)!;
+		expect(link.content).toMatchObject({
+			mode: 'link',
+			previewTitle: 'Linktitel',
+			description: 'Öffentlicher Anreißer',
+			embedUrl: '',
+			source: { label: 'Artikel', url: 'https://example.com/artikel' }
+		});
+		const serialized = JSON.stringify(link);
+		expect(serialized).not.toContain('Herstellerangaben');
+		expect(serialized).not.toContain('Moderationsstichpunkte');
+	});
+});

src/lib/server/live.ts

@@ -0,0 +1,842 @@
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import type Database from 'better-sqlite3';
+import { getServerPaths } from './config.js';
+import { getDatabase } from './database.js';
+import { renderMarkdown } from './markdown.js';
+import { buildEmbedUrl, fetchPresentationImage, type PresentationContent } from './presentation.js';
+import {
+	getShow,
+	movePieceUsage,
+	type MovePieceUsageInput,
+	type PieceUsage,
+	type ShowSection
+} from './shows.js';
+
+type LiveStateRow = {
+	show_id: string;
+	revision: number;
+	current_usage_id: string | null;
+	started_at_utc: string | null;
+	ended_at_utc: string | null;
+	presentation_usage_id: string | null;
+	presentation_revision: number;
+	updated_at_utc: string;
+};
+
+type OrderedUsageRow = {
+	id: string;
+	section_id: string;
+	section_name: string;
+	section_position: number;
+	position: number;
+	status: PieceUsage['status'];
+};
+
+export type LiveUsage = PieceUsage & {
+	sectionId: string;
+	sectionName: string;
+	actualDurationSeconds: number;
+	introHtml: string;
+	researchHtml: string;
+	moderationHtml: string;
+	transitionHtml: string;
+};
+
+export type LiveSection = Omit<ShowSection, 'usages'> & { usages: LiveUsage[] };
+
+export type LiveView = {
+	show: {
+		id: string;
+		title: string;
+		status: string;
+		revision: number;
+		totalDurationSeconds: number;
+	};
+	liveRevision: number;
+	startedAtUtc: string | null;
+	updatedAtUtc: string;
+	presentationUsageId: string | null;
+	presentationRevision: number;
+	sections: LiveSection[];
+	reserve: LiveUsage[];
+	current: LiveUsage | null;
+	next: LiveUsage | null;
+	completedCount: number;
+	totalCount: number;
+	sectionTimer: null | {
+		sectionId: string;
+		sectionName: string;
+		plannedDurationSeconds: number;
+		elapsedSeconds: number;
+		runningSinceUtc: string | null;
+	};
+};
+
+export type PresentationView = {
+	revision: number;
+	content: null | {
+		mode: PresentationContent['mode'];
+		topics: string[];
+		title: string;
+		html: string;
+		source: PresentationContent['source'];
+		previewTitle: string;
+		description: string;
+		imageUrl: string;
+		siteName: string;
+		provider: PresentationContent['provider'];
+		providerId: string;
+		embedUrl: string;
+		sources: { label: string; url: string; timecodeSeconds: number | null }[];
+		images: { id: string; altText: string }[];
+	};
+};
+
+function hashToken(token: string) {
+	return createHash('sha256').update(token).digest('hex');
+}
+
+function nowIso(now?: Date) {
+	return (now ?? new Date()).toISOString();
+}
+
+function requireCommandId(commandId: string) {
+	if (!commandId || commandId.length > 200) throw new Error('INVALID_COMMAND');
+}
+
+function ensureLiveState(database: Database.Database, showId: string, now: string): LiveStateRow {
+	const show = database.prepare('SELECT 1 FROM shows WHERE id = ?').get(showId);
+	if (!show) throw new Error('NOT_FOUND');
+	database
+		.prepare(
+			`INSERT OR IGNORE INTO show_live_states (show_id, updated_at_utc)
+			 VALUES (?, ?)`
+		)
+		.run(showId, now);
+	return database
+		.prepare('SELECT * FROM show_live_states WHERE show_id = ?')
+		.get(showId) as LiveStateRow;
+}
+
+function orderedUsages(database: Database.Database, showId: string): OrderedUsageRow[] {
+	return database
+		.prepare(
+			`SELECT u.id, s.id AS section_id, s.name AS section_name,
+			 s.position AS section_position, u.position, u.status
+			 FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
+			 WHERE s.show_id = ? AND s.is_reserve_bank = 0
+			 ORDER BY s.position, u.position`
+		)
+		.all(showId) as OrderedUsageRow[];
+}
+
+function usageBelongsToShow(database: Database.Database, showId: string, usageId: string) {
+	const row = database
+		.prepare(
+			`SELECT s.is_reserve_bank FROM piece_usages u
+			 JOIN show_sections s ON s.id = u.show_section_id
+			 WHERE u.id = ? AND s.show_id = ?`
+		)
+		.get(usageId, showId) as { is_reserve_bank: number } | undefined;
+	if (!row || row.is_reserve_bank) throw new Error('NOT_FOUND');
+}
+
+function closeActiveRun(database: Database.Database, showId: string, now: string) {
+	database
+		.prepare(
+			`UPDATE live_usage_runs SET ended_at_utc = ?
+			 WHERE show_id = ? AND ended_at_utc IS NULL`
+		)
+		.run(now, showId);
+}
+
+function closeSectionTimer(database: Database.Database, showId: string, now: string) {
+	const timer = database
+		.prepare('SELECT id FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL')
+		.get(showId) as { id: string } | undefined;
+	if (!timer) return;
+	database
+		.prepare(
+			'UPDATE live_section_timer_runs SET ended_at_utc = ? WHERE timer_id = ? AND ended_at_utc IS NULL'
+		)
+		.run(now, timer.id);
+	database
+		.prepare('UPDATE live_section_timers SET ended_at_utc = ? WHERE id = ?')
+		.run(now, timer.id);
+}
+
+function syncSectionTimer(
+	database: Database.Database,
+	showId: string,
+	usageId: string,
+	now: string
+) {
+	const section = database
+		.prepare(
+			`SELECT s.id, s.explicit_duration_seconds FROM piece_usages u
+			 JOIN show_sections s ON s.id = u.show_section_id
+			 WHERE u.id = ? AND s.show_id = ? AND s.is_reserve_bank = 0`
+		)
+		.get(usageId, showId) as { id: string; explicit_duration_seconds: number | null } | undefined;
+	if (!section) throw new Error('NOT_FOUND');
+	const active = database
+		.prepare(
+			'SELECT id, section_id FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL'
+		)
+		.get(showId) as { id: string; section_id: string } | undefined;
+	if (active?.section_id === section.id) return;
+	if (active) closeSectionTimer(database, showId, now);
+	if (!section.explicit_duration_seconds || section.explicit_duration_seconds <= 0) return;
+	const timerId = randomUUID();
+	database
+		.prepare(
+			`INSERT INTO live_section_timers
+			 (id, show_id, section_id, planned_duration_seconds, started_at_utc)
+			 VALUES (?, ?, ?, ?, ?)`
+		)
+		.run(timerId, showId, section.id, section.explicit_duration_seconds, now);
+	database
+		.prepare(
+			`INSERT INTO live_section_timer_runs (id, timer_id, started_at_utc)
+			 VALUES (?, ?, ?)`
+		)
+		.run(randomUUID(), timerId, now);
+}
+
+function activateUsage(database: Database.Database, showId: string, usageId: string, now: string) {
+	usageBelongsToShow(database, showId, usageId);
+	database
+		.prepare(
+			`UPDATE piece_usages SET status = 'open'
+			 WHERE status = 'current' AND id != ? AND id IN (
+				SELECT u.id FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
+				WHERE s.show_id = ?
+			 )`
+		)
+		.run(usageId, showId);
+	database.prepare(`UPDATE piece_usages SET status = 'current' WHERE id = ?`).run(usageId);
+	database
+		.prepare(
+			`INSERT INTO live_usage_runs (id, show_id, usage_id, started_at_utc)
+			 VALUES (?, ?, ?, ?)`
+		)
+		.run(randomUUID(), showId, usageId, now);
+	database
+		.prepare(
+			'UPDATE show_live_states SET current_usage_id = ?, ended_at_utc = NULL WHERE show_id = ?'
+		)
+		.run(usageId, showId);
+	syncSectionTimer(database, showId, usageId, now);
+}
+
+function executeCommand(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	action: string,
+	operation: (database: Database.Database, state: LiveStateRow, now: string) => void,
+	nowValue?: Date
+) {
+	requireCommandId(commandId);
+	const database = getDatabase();
+	return database.transaction(() => {
+		const duplicate = database
+			.prepare('SELECT result_revision FROM live_commands WHERE show_id = ? AND command_id = ?')
+			.get(showId, commandId) as { result_revision: number } | undefined;
+		if (duplicate) return { revision: duplicate.result_revision, duplicate: true };
+		const now = nowIso(nowValue);
+		const state = ensureLiveState(database, showId, now);
+		const show = database.prepare('SELECT status FROM shows WHERE id = ?').get(showId) as {
+			status: string;
+		};
+		if (show.status === 'completed') throw new Error('SHOW_COMPLETED');
+		if (state.revision !== expectedRevision) throw new Error('CONFLICT');
+		operation(database, state, now);
+		const updated = database
+			.prepare(
+				`UPDATE show_live_states SET revision = revision + 1, updated_at_utc = ?
+				 WHERE show_id = ? AND revision = ?`
+			)
+			.run(now, showId, expectedRevision);
+		if (updated.changes !== 1) throw new Error('CONFLICT');
+		const revision = expectedRevision + 1;
+		database
+			.prepare(
+				`INSERT INTO live_commands (show_id, command_id, action, result_revision, created_at_utc)
+				 VALUES (?, ?, ?, ?, ?)`
+			)
+			.run(showId, commandId, action, revision, now);
+		return { revision, duplicate: false };
+	})();
+}
+
+function actualDurations(database: Database.Database, showId: string, now: string) {
+	const rows = database
+		.prepare(
+			`SELECT usage_id, started_at_utc, ended_at_utc
+			 FROM live_usage_runs WHERE show_id = ?`
+		)
+		.all(showId) as { usage_id: string; started_at_utc: string; ended_at_utc: string | null }[];
+	const durations = new Map<string, number>();
+	for (const row of rows) {
+		const seconds = Math.max(
+			0,
+			Math.floor(
+				(new Date(row.ended_at_utc ?? now).getTime() - new Date(row.started_at_utc).getTime()) /
+					1000
+			)
+		);
+		durations.set(row.usage_id, (durations.get(row.usage_id) ?? 0) + seconds);
+	}
+	return durations;
+}
+
+function liveUsage(
+	usage: PieceUsage,
+	sectionId: string,
+	sectionName: string,
+	actualSeconds: number
+) {
+	return {
+		...usage,
+		sectionId,
+		sectionName,
+		actualDurationSeconds: actualSeconds,
+		introHtml: renderMarkdown(usage.intro),
+		researchHtml: renderMarkdown(usage.research),
+		moderationHtml: renderMarkdown(usage.moderation),
+		transitionHtml: renderMarkdown(usage.transition)
+	};
+}
+
+export function getLiveView(showId: string, nowValue?: Date): LiveView {
+	const database = getDatabase();
+	const now = nowIso(nowValue);
+	const state = ensureLiveState(database, showId, now);
+	const show = getShow(showId);
+	if (!show) throw new Error('NOT_FOUND');
+	const durations = actualDurations(database, showId, now);
+	const sections = show.sections.map((section) => ({
+		...section,
+		usages: section.usages.map((usage) =>
+			liveUsage(usage, section.id, section.name, durations.get(usage.id) ?? 0)
+		)
+	}));
+	const reserve = show.reserve.map((usage) =>
+		liveUsage(usage, '', 'Reservebank', durations.get(usage.id) ?? 0)
+	);
+	const usages = sections.flatMap((section) => section.usages);
+	const current = usages.find((usage) => usage.id === state.current_usage_id) ?? null;
+	const currentIndex = current ? usages.findIndex((usage) => usage.id === current.id) : -1;
+	const next =
+		usages.slice(currentIndex + 1).find((usage) => usage.status === 'open') ??
+		(current ? null : (usages.find((usage) => usage.status === 'open') ?? null));
+	const timer = database
+		.prepare(
+			`SELECT t.id, t.section_id, s.name AS section_name, t.planned_duration_seconds
+			 FROM live_section_timers t JOIN show_sections s ON s.id = t.section_id
+			 WHERE t.show_id = ? AND t.ended_at_utc IS NULL`
+		)
+		.get(showId) as
+		| { id: string; section_id: string; section_name: string; planned_duration_seconds: number }
+		| undefined;
+	let sectionTimer: LiveView['sectionTimer'] = null;
+	if (timer) {
+		const runs = database
+			.prepare(
+				`SELECT started_at_utc, ended_at_utc FROM live_section_timer_runs
+				 WHERE timer_id = ? ORDER BY started_at_utc`
+			)
+			.all(timer.id) as { started_at_utc: string; ended_at_utc: string | null }[];
+		const running = runs.find((run) => run.ended_at_utc === null) ?? null;
+		const elapsedSeconds = runs.reduce(
+			(total, run) =>
+				total +
+				Math.max(
+					0,
+					Math.floor(
+						(new Date(run.ended_at_utc ?? now).getTime() - new Date(run.started_at_utc).getTime()) /
+							1_000
+					)
+				),
+			0
+		);
+		sectionTimer = {
+			sectionId: timer.section_id,
+			sectionName: timer.section_name,
+			plannedDurationSeconds: timer.planned_duration_seconds,
+			elapsedSeconds,
+			runningSinceUtc: running?.started_at_utc ?? null
+		};
+	}
+	return {
+		show: {
+			id: show.id,
+			title: show.title,
+			status: show.status,
+			revision: show.revision,
+			totalDurationSeconds: show.totalDurationSeconds
+		},
+		liveRevision: state.revision,
+		startedAtUtc: state.started_at_utc,
+		updatedAtUtc: state.updated_at_utc,
+		presentationUsageId: state.presentation_usage_id,
+		presentationRevision: state.presentation_revision,
+		sections,
+		reserve,
+		current,
+		next,
+		completedCount: usages.filter((usage) => usage.status === 'done' || usage.status === 'skipped')
+			.length,
+		totalCount: usages.length,
+		sectionTimer
+	};
+}
+
+export function startOrResumeLive(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		'start',
+		(database, state, now) => {
+			database
+				.prepare(
+					`UPDATE shows SET status = 'live', updated_at_utc = ?
+					 WHERE id = ? AND status != 'completed'`
+				)
+				.run(now, showId);
+			database
+				.prepare(
+					`UPDATE show_live_states SET started_at_utc = COALESCE(started_at_utc, ?), ended_at_utc = NULL
+					 WHERE show_id = ?`
+				)
+				.run(now, showId);
+			const activeRun = database
+				.prepare('SELECT 1 FROM live_usage_runs WHERE show_id = ? AND ended_at_utc IS NULL')
+				.get(showId);
+			if (state.current_usage_id && activeRun) return;
+			const current = state.current_usage_id
+				? orderedUsages(database, showId).find((usage) => usage.id === state.current_usage_id)
+				: undefined;
+			const target =
+				current ?? orderedUsages(database, showId).find((usage) => usage.status === 'open');
+			if (target) activateUsage(database, showId, target.id, now);
+		},
+		nowValue
+	);
+}
+
+function advanceCurrent(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	status: 'done' | 'skipped',
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		status,
+		(database, state, now) => {
+			if (!state.current_usage_id) throw new Error('NO_CURRENT');
+			const ordered = orderedUsages(database, showId);
+			const currentIndex = ordered.findIndex((usage) => usage.id === state.current_usage_id);
+			if (currentIndex < 0) throw new Error('NOT_FOUND');
+			closeActiveRun(database, showId, now);
+			database
+				.prepare('UPDATE piece_usages SET status = ? WHERE id = ?')
+				.run(status, state.current_usage_id);
+			const next = ordered.slice(currentIndex + 1).find((usage) => usage.status === 'open');
+			if (next) activateUsage(database, showId, next.id, now);
+			else {
+				closeSectionTimer(database, showId, now);
+				database
+					.prepare('UPDATE show_live_states SET current_usage_id = NULL WHERE show_id = ?')
+					.run(showId);
+			}
+		},
+		nowValue
+	);
+}
+
+export function completeCurrent(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return advanceCurrent(showId, commandId, expectedRevision, 'done', nowValue);
+}
+
+export function skipCurrent(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return advanceCurrent(showId, commandId, expectedRevision, 'skipped', nowValue);
+}
+
+export function goBack(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		'back',
+		(database, state, now) => {
+			const ordered = orderedUsages(database, showId);
+			const currentIndex = state.current_usage_id
+				? ordered.findIndex((usage) => usage.id === state.current_usage_id)
+				: ordered.length;
+			const previous = ordered
+				.slice(0, Math.max(0, currentIndex))
+				.reverse()
+				.find((usage) => usage.status === 'done' || usage.status === 'skipped');
+			if (!previous) throw new Error('NO_PREVIOUS');
+			if (state.current_usage_id) {
+				closeActiveRun(database, showId, now);
+				database
+					.prepare(`UPDATE piece_usages SET status = 'open' WHERE id = ?`)
+					.run(state.current_usage_id);
+			}
+			activateUsage(database, showId, previous.id, now);
+		},
+		nowValue
+	);
+}
+
+export function selectUsage(
+	showId: string,
+	usageId: string,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		'select',
+		(database, state, now) => {
+			if (!state.started_at_utc) throw new Error('NOT_STARTED');
+			usageBelongsToShow(database, showId, usageId);
+			if (state.current_usage_id === usageId) return;
+			if (state.current_usage_id) {
+				closeActiveRun(database, showId, now);
+				database
+					.prepare("UPDATE piece_usages SET status = 'open' WHERE id = ?")
+					.run(state.current_usage_id);
+			}
+			activateUsage(database, showId, usageId, now);
+		},
+		nowValue
+	);
+}
+
+export function presentUsage(
+	showId: string,
+	usageId: string | null,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		usageId ? 'present' : 'clear-presentation',
+		(database, _state, now) => {
+			if (usageId) usageBelongsToShow(database, showId, usageId);
+			database
+				.prepare(
+					`UPDATE show_live_states SET presentation_usage_id = ?,
+					 presentation_revision = presentation_revision + 1, updated_at_utc = ?
+					 WHERE show_id = ?`
+				)
+				.run(usageId, now, showId);
+		},
+		nowValue
+	);
+}
+
+export function moveOpenUsage(
+	showId: string,
+	usageId: string,
+	expectedShowRevision: number,
+	input: MovePieceUsageInput
+) {
+	const database = getDatabase();
+	const usage = database
+		.prepare(
+			`SELECT u.status FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
+			 WHERE u.id = ? AND s.show_id = ?`
+		)
+		.get(usageId, showId) as { status: PieceUsage['status'] } | undefined;
+	if (!usage) throw new Error('NOT_FOUND');
+	if (usage.status !== 'open') throw new Error('LIVE_ORDER_LOCKED');
+	if (input.sectionId) {
+		const target = database
+			.prepare(
+				`SELECT u.id, u.status FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
+				 WHERE s.id = ? AND s.show_id = ? AND s.is_reserve_bank = 0 ORDER BY u.position`
+			)
+			.all(input.sectionId, showId) as { id: string; status: PieceUsage['status'] }[];
+		if (!target.length) {
+			const section = database
+				.prepare('SELECT 1 FROM show_sections WHERE id = ? AND show_id = ? AND is_reserve_bank = 0')
+				.get(input.sectionId, showId);
+			if (!section) throw new Error('NOT_FOUND');
+		}
+		const withoutMoved = target.filter((item) => item.id !== usageId);
+		const firstOpenPosition = withoutMoved.findIndex((item) => item.status === 'open');
+		const minimum = firstOpenPosition < 0 ? withoutMoved.length : firstOpenPosition;
+		if (input.position < minimum) throw new Error('LIVE_ORDER_LOCKED');
+	}
+	return movePieceUsage(showId, usageId, expectedShowRevision, input);
+}
+
+export function issuePresentationAccess(showId: string) {
+	const database = getDatabase();
+	const now = nowIso();
+	ensureLiveState(database, showId, now);
+	return database.transaction(() => {
+		let channel = database
+			.prepare("SELECT * FROM presentation_channels WHERE id = 'default'")
+			.get() as { access_key: string; show_id: string | null } | undefined;
+		if (!channel) {
+			const accessKey = randomBytes(32).toString('base64url');
+			clearPresentationState(database, showId);
+			database
+				.prepare(
+					`INSERT INTO presentation_channels
+					 (id, name, access_key, key_hash, show_id, revision, created_at_utc, updated_at_utc)
+					 VALUES ('default', 'Standardausgabe', ?, ?, ?, 1, ?, ?)`
+				)
+				.run(accessKey, hashToken(accessKey), showId, now, now);
+			channel = { access_key: accessKey, show_id: showId };
+		} else if (channel.show_id !== showId) {
+			clearPresentationState(database, showId);
+			database
+				.prepare(
+					`UPDATE presentation_channels SET show_id = ?, revision = revision + 1,
+					 updated_at_utc = ? WHERE id = 'default'`
+				)
+				.run(showId, now);
+		}
+		return channel.access_key;
+	})();
+}
+
+function clearPresentationState(database: Database.Database, showId: string) {
+	database
+		.prepare(
+			`UPDATE show_live_states SET presentation_usage_id = NULL,
+			 presentation_revision = presentation_revision + 1, updated_at_utc = ?
+			 WHERE show_id = ? AND presentation_usage_id IS NOT NULL`
+		)
+		.run(nowIso(), showId);
+}
+
+export function clearPresentationChannel() {
+	const now = nowIso();
+	getDatabase().transaction(() => {
+		const database = getDatabase();
+		const channel = database
+			.prepare("SELECT show_id FROM presentation_channels WHERE id = 'default'")
+			.get() as { show_id: string | null } | undefined;
+		if (!channel) throw new Error('NOT_FOUND');
+		if (channel.show_id) clearPresentationState(database, channel.show_id);
+		database
+			.prepare(
+				`UPDATE presentation_channels SET show_id = NULL, revision = revision + 1,
+				 updated_at_utc = ? WHERE id = 'default'`
+			)
+			.run(now);
+	})();
+}
+
+export function rotatePresentationChannelKey(showId: string) {
+	issuePresentationAccess(showId);
+	const accessKey = randomBytes(32).toString('base64url');
+	const now = nowIso();
+	getDatabase()
+		.prepare(
+			`UPDATE presentation_channels SET access_key = ?, key_hash = ?, revision = revision + 1,
+			 updated_at_utc = ? WHERE id = 'default'`
+		)
+		.run(accessKey, hashToken(accessKey), now);
+	return accessKey;
+}
+
+export function presentationChannelAccess(channelId: string, accessKey: string) {
+	if (!channelId || !accessKey || accessKey.length > 200) return false;
+	return Boolean(
+		getDatabase()
+			.prepare('SELECT 1 FROM presentation_channels WHERE id = ? AND key_hash = ?')
+			.get(channelId, hashToken(accessKey))
+	);
+}
+
+function presentationShowId(database: Database.Database, token: string) {
+	if (!token || token.length > 200) return null;
+	const channel = database
+		.prepare('SELECT show_id FROM presentation_channels WHERE key_hash = ?')
+		.get(hashToken(token)) as { show_id: string | null } | undefined;
+	if (channel) return channel.show_id;
+	const row = database
+		.prepare(
+			`SELECT show_id FROM presentation_access_tokens
+			 WHERE token_hash = ? AND revoked_at_utc IS NULL`
+		)
+		.get(hashToken(token)) as { show_id: string } | undefined;
+	return row?.show_id ?? null;
+}
+
+export function getPresentationChannelView(channelId: string): PresentationView | null {
+	const channel = getDatabase()
+		.prepare('SELECT show_id, revision FROM presentation_channels WHERE id = ?')
+		.get(channelId) as { show_id: string | null; revision: number } | undefined;
+	if (!channel) return null;
+	if (!channel.show_id) return { revision: channel.revision * 1_000_000_000, content: null };
+	const view = getPresentationViewForShow(channel.show_id);
+	return { ...view, revision: channel.revision * 1_000_000_000 + view.revision };
+}
+
+export function getPresentationView(token: string): PresentationView | null {
+	const database = getDatabase();
+	const showId = presentationShowId(database, token);
+	if (!showId) return null;
+	return getPresentationViewForShow(showId);
+}
+
+function getPresentationViewForShow(showId: string): PresentationView {
+	const database = getDatabase();
+	const state = ensureLiveState(database, showId, nowIso());
+	if (!state.presentation_usage_id) return { revision: state.presentation_revision, content: null };
+	const usage = database
+		.prepare(
+			`SELECT u.title_snapshot, u.output_title_snapshot, u.presentation_snapshot,
+			 u.presentation_mode_snapshot, u.presentation_source_label_snapshot,
+			 u.presentation_source_url_snapshot, u.presentation_source_timecode_snapshot,
+			 u.presentation_title_meta_snapshot, u.presentation_description_snapshot,
+			 u.presentation_image_url_snapshot, u.presentation_site_name_snapshot,
+			 u.presentation_provider_snapshot, u.presentation_provider_id_snapshot
+			 FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
+			 WHERE u.id = ? AND s.show_id = ? AND s.is_reserve_bank = 0`
+		)
+		.get(state.presentation_usage_id, showId) as
+		| {
+				title_snapshot: string;
+				output_title_snapshot: string;
+				presentation_snapshot: string;
+				presentation_mode_snapshot: PresentationContent['mode'];
+				presentation_source_label_snapshot: string;
+				presentation_source_url_snapshot: string;
+				presentation_source_timecode_snapshot: number | null;
+				presentation_title_meta_snapshot: string;
+				presentation_description_snapshot: string;
+				presentation_image_url_snapshot: string;
+				presentation_site_name_snapshot: string;
+				presentation_provider_snapshot: PresentationContent['provider'];
+				presentation_provider_id_snapshot: string;
+		  }
+		| undefined;
+	if (!usage) return { revision: state.presentation_revision, content: null };
+	return {
+		revision: state.presentation_revision,
+		content: {
+			mode: usage.presentation_mode_snapshot,
+			topics: (
+				database
+					.prepare('SELECT name FROM usage_topic_snapshots WHERE usage_id = ? ORDER BY position')
+					.all(state.presentation_usage_id) as { name: string }[]
+			).map((topic) => topic.name),
+			title: usage.output_title_snapshot || usage.title_snapshot,
+			html: renderMarkdown(usage.presentation_snapshot),
+			source: usage.presentation_source_url_snapshot
+				? {
+						label: usage.presentation_source_label_snapshot,
+						url: usage.presentation_source_url_snapshot,
+						timecodeSeconds: usage.presentation_source_timecode_snapshot
+					}
+				: null,
+			previewTitle: usage.presentation_title_meta_snapshot,
+			description: usage.presentation_description_snapshot,
+			imageUrl: usage.presentation_image_url_snapshot,
+			siteName: usage.presentation_site_name_snapshot,
+			provider: usage.presentation_provider_snapshot,
+			providerId: usage.presentation_provider_id_snapshot,
+			embedUrl: buildEmbedUrl(
+				usage.presentation_provider_snapshot,
+				usage.presentation_provider_id_snapshot,
+				usage.presentation_source_timecode_snapshot
+			),
+			sources: [],
+			images: (
+				database
+					.prepare(
+						`SELECT id, alt_text FROM usage_media_snapshots
+						 WHERE usage_id = ? AND is_presentation = 1`
+					)
+					.all(state.presentation_usage_id) as { id: string; alt_text: string }[]
+			).map((media) => ({ id: media.id, altText: media.alt_text }))
+		}
+	};
+}
+
+export async function getPresentationPreviewImage(token: string) {
+	const view = getPresentationView(token);
+	if (!view?.content?.imageUrl || view.content.mode === 'text') return null;
+	try {
+		return await fetchPresentationImage(view.content.imageUrl);
+	} catch {
+		return null;
+	}
+}
+
+export async function getPresentationMedia(
+	token: string,
+	snapshotId: string
+): Promise<{ data: Buffer; mimeType: string; byteSize: number; altText: string } | null> {
+	const database = getDatabase();
+	const showId = presentationShowId(database, token);
+	if (!showId || !snapshotId) return null;
+	const media = database
+		.prepare(
+			`SELECT pm.storage_name, pm.mime_type, pm.byte_size, ums.alt_text
+			 FROM show_live_states state
+			 JOIN usage_media_snapshots ums ON ums.usage_id = state.presentation_usage_id
+			 JOIN piece_usages u ON u.id = ums.usage_id
+			 JOIN show_sections s ON s.id = u.show_section_id
+			 JOIN piece_media pm ON pm.id = ums.original_media_id
+			 WHERE state.show_id = ? AND s.show_id = state.show_id
+			 AND s.is_reserve_bank = 0 AND ums.id = ? AND ums.is_presentation = 1`
+		)
+		.get(showId, snapshotId) as
+		{ storage_name: string; mime_type: string; byte_size: number; alt_text: string } | undefined;
+	if (!media) return null;
+	try {
+		return {
+			data: await readFile(path.join(getServerPaths().uploads, media.storage_name)),
+			mimeType: media.mime_type,
+			byteSize: media.byte_size,
+			altText: media.alt_text
+		};
+	} catch {
+		return null;
+	}
+}

src/lib/server/presentation.spec.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+import {
+	buildEmbedUrl,
+	detectVideoProvider,
+	extractMetadataFromHtml,
+	fetchPresentationMetadata
+} from './presentation.js';
+
+describe('presentation metadata and providers', () => {
+	it('recognizes supported YouTube URL forms and creates privacy-enhanced embeds with start time', () => {
+		for (const url of [
+			'https://www.youtube.com/watch?v=dQw4w9WgXcQ',
+			'https://youtu.be/dQw4w9WgXcQ',
+			'https://www.youtube.com/shorts/dQw4w9WgXcQ',
+			'https://youtube.com/live/dQw4w9WgXcQ'
+		]) {
+			expect(detectVideoProvider(url)).toEqual({ provider: 'youtube', id: 'dQw4w9WgXcQ' });
+		}
+		expect(buildEmbedUrl('youtube', 'dQw4w9WgXcQ', 75)).toBe(
+			'https://www.youtube-nocookie.com/embed/dQw4w9WgXcQ?start=75'
+		);
+		expect(detectVideoProvider('https://evil.example/watch?v=dQw4w9WgXcQ')).toBeNull();
+		expect(detectVideoProvider('https://youtube.com/watch?v=invalid')).toBeNull();
+	});
+
+	it('recognizes canonical TikTok videos without inventing a start parameter', () => {
+		expect(
+			detectVideoProvider('https://www.tiktok.com/@scout2015/video/6718335390845095173')
+		).toEqual({ provider: 'tiktok', id: '6718335390845095173' });
+		expect(buildEmbedUrl('tiktok', '6718335390845095173', 90)).toBe(
+			'https://www.tiktok.com/player/v1/6718335390845095173?autoplay=0&controls=1'
+		);
+	});
+
+	it('extracts generic metadata from local HTML and tolerates a missing image', async () => {
+		const metadata = await extractMetadataFromHtml(
+			`<!doctype html><html><head>
+				<meta property="og:title" content="Lokale Vorschau">
+				<meta property="og:description" content="Ein kurzer Anreißer">
+				<meta property="og:site_name" content="Testseite">
+			</head></html>`,
+			'https://example.com/artikel'
+		);
+		expect(metadata).toMatchObject({
+			title: 'Lokale Vorschau',
+			description: 'Ein kurzer Anreißer',
+			imageUrl: '',
+			siteName: 'Testseite'
+		});
+	});
+
+	it('rejects malformed and private metadata targets before a network request', async () => {
+		await expect(fetchPresentationMetadata('keine-url')).rejects.toThrow('FETCH_INVALID_URL');
+		await expect(fetchPresentationMetadata('http://127.0.0.1/private')).rejects.toThrow(
+			'FETCH_BLOCKED'
+		);
+		await expect(fetchPresentationMetadata('http://[::1]/private')).rejects.toThrow(
+			'FETCH_BLOCKED'
+		);
+	});
+});

src/lib/server/presentation.ts

@@ -0,0 +1,275 @@
+import { lookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
+import http from 'node:http';
+import https from 'node:https';
+import metascraper from 'metascraper';
+import description from 'metascraper-description';
+import image from 'metascraper-image';
+import publisher from 'metascraper-publisher';
+import title from 'metascraper-title';
+
+export type PresentationMode = 'text' | 'link' | 'video';
+export type VideoProvider = 'youtube' | 'tiktok';
+
+export type PresentationMetadata = {
+	title: string;
+	description: string;
+	imageUrl: string;
+	siteName: string;
+	provider: VideoProvider | '';
+	providerId: string;
+};
+
+export type PresentationSource = {
+	label: string;
+	url: string;
+	timecodeSeconds: number | null;
+};
+
+export type PresentationContent = {
+	mode: PresentationMode;
+	topics: string[];
+	title: string;
+	html: string;
+	source: PresentationSource | null;
+	previewTitle: string;
+	description: string;
+	imageUrl: string;
+	siteName: string;
+	provider: VideoProvider | '';
+	providerId: string;
+	embedUrl: string;
+};
+
+const scrape = metascraper([title(), description({ truncateLength: 500 }), image(), publisher()]);
+const MAX_HTML_BYTES = 1024 * 1024;
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+const REQUEST_TIMEOUT_MS = 5_000;
+const MAX_REDIRECTS = 3;
+
+function isPrivateIpv4(address: string) {
+	const parts = address.split('.').map(Number);
+	return (
+		parts[0] === 0 ||
+		parts[0] === 10 ||
+		parts[0] === 127 ||
+		(parts[0] === 169 && parts[1] === 254) ||
+		(parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) ||
+		(parts[0] === 192 && parts[1] === 168) ||
+		(parts[0] === 100 && parts[1] >= 64 && parts[1] <= 127) ||
+		parts[0] >= 224
+	);
+}
+
+function isPrivateAddress(address: string) {
+	if (isIP(address) === 4) return isPrivateIpv4(address);
+	const normalized = address.toLowerCase().split('%')[0];
+	if (normalized === '::' || normalized === '::1') return true;
+	if (normalized.startsWith('fc') || normalized.startsWith('fd') || normalized.startsWith('fe8')) {
+		return true;
+	}
+	if (
+		normalized.startsWith('fe9') ||
+		normalized.startsWith('fea') ||
+		normalized.startsWith('feb')
+	) {
+		return true;
+	}
+	const mapped = normalized.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/)?.[1];
+	return mapped ? isPrivateIpv4(mapped) : false;
+}
+
+async function publicAddress(url: URL) {
+	if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) {
+		throw new Error('FETCH_BLOCKED');
+	}
+	if (url.port && url.port !== (url.protocol === 'https:' ? '443' : '80')) {
+		throw new Error('FETCH_BLOCKED');
+	}
+	const hostname = url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname;
+	if (hostname === 'localhost' || hostname.endsWith('.localhost')) {
+		throw new Error('FETCH_BLOCKED');
+	}
+	const addresses = isIP(hostname)
+		? [{ address: hostname, family: isIP(hostname) }]
+		: await lookup(hostname, { all: true, verbatim: true }).catch(() => {
+				throw new Error('FETCH_UNAVAILABLE');
+			});
+	if (!addresses.length || addresses.some((entry) => isPrivateAddress(entry.address))) {
+		throw new Error('FETCH_BLOCKED');
+	}
+	return addresses[0];
+}
+
+async function requestPublic(
+	input: string,
+	accept: string,
+	maximumBytes: number,
+	redirects = 0
+): Promise<{ url: string; contentType: string; data: Buffer }> {
+	let url: URL;
+	try {
+		url = new URL(input);
+	} catch {
+		throw new Error('FETCH_INVALID_URL');
+	}
+	const target = await publicAddress(url);
+	const client = url.protocol === 'https:' ? https : http;
+	return new Promise((resolve, reject) => {
+		const request = client.get(
+			url,
+			{
+				headers: {
+					Accept: accept,
+					'User-Agent': 'Sendewerk/0.5.1 (+https://git.hnz.io/hnzio/sendewerk)'
+				},
+				lookup: (_hostname, _options, callback) =>
+					callback(null, target.address, target.family as 4 | 6)
+			},
+			(response) => {
+				const status = response.statusCode ?? 0;
+				if (status >= 300 && status < 400 && response.headers.location) {
+					response.resume();
+					if (redirects >= MAX_REDIRECTS) return reject(new Error('FETCH_REDIRECTS'));
+					const next = new URL(response.headers.location, url).href;
+					requestPublic(next, accept, maximumBytes, redirects + 1).then(resolve, reject);
+					return;
+				}
+				if (status < 200 || status >= 300) {
+					response.resume();
+					return reject(new Error('FETCH_UNAVAILABLE'));
+				}
+				const chunks: Buffer[] = [];
+				let size = 0;
+				response.on('data', (chunk: Buffer) => {
+					size += chunk.length;
+					if (size > maximumBytes) {
+						request.destroy(new Error('FETCH_TOO_LARGE'));
+						return;
+					}
+					chunks.push(chunk);
+				});
+				response.on('end', () =>
+					resolve({
+						url: url.href,
+						contentType: String(response.headers['content-type'] ?? ''),
+						data: Buffer.concat(chunks)
+					})
+				);
+			}
+		);
+		request.setTimeout(REQUEST_TIMEOUT_MS, () => request.destroy(new Error('FETCH_TIMEOUT')));
+		request.on('error', reject);
+	});
+}
+
+export function detectVideoProvider(input: string): {
+	provider: VideoProvider;
+	id: string;
+} | null {
+	let url: URL;
+	try {
+		url = new URL(input);
+	} catch {
+		return null;
+	}
+	if (url.protocol !== 'https:' || url.username || url.password || url.port) return null;
+	const host = url.hostname.toLowerCase();
+	let youtubeId = '';
+	if (host === 'youtu.be') youtubeId = url.pathname.split('/').filter(Boolean)[0] ?? '';
+	if (host === 'youtube.com' || host === 'www.youtube.com' || host === 'm.youtube.com') {
+		if (url.pathname === '/watch') youtubeId = url.searchParams.get('v') ?? '';
+		else if (/^\/(shorts|embed|live)\//.test(url.pathname)) {
+			youtubeId = url.pathname.split('/').filter(Boolean)[1] ?? '';
+		}
+	}
+	if (/^[A-Za-z0-9_-]{11}$/.test(youtubeId)) {
+		return { provider: 'youtube', id: youtubeId };
+	}
+	if (host === 'tiktok.com' || host === 'www.tiktok.com' || host === 'm.tiktok.com') {
+		const id = url.pathname.match(/\/video\/(\d+)/)?.[1] ?? '';
+		if (/^\d+$/.test(id)) return { provider: 'tiktok', id };
+	}
+	return null;
+}
+
+export function buildEmbedUrl(
+	provider: VideoProvider | '',
+	providerId: string,
+	timecodeSeconds: number | null
+) {
+	if (provider === 'youtube' && /^[A-Za-z0-9_-]{11}$/.test(providerId)) {
+		const url = new URL(`https://www.youtube-nocookie.com/embed/${providerId}`);
+		if (timecodeSeconds && timecodeSeconds > 0)
+			url.searchParams.set('start', String(timecodeSeconds));
+		return url.href;
+	}
+	if (provider === 'tiktok' && /^\d+$/.test(providerId)) {
+		const url = new URL(`https://www.tiktok.com/player/v1/${providerId}`);
+		url.searchParams.set('autoplay', '0');
+		url.searchParams.set('controls', '1');
+		return url.href;
+	}
+	return '';
+}
+
+export async function extractMetadataFromHtml(
+	html: string,
+	url: string
+): Promise<PresentationMetadata> {
+	const metadata = await scrape({ html, url });
+	return {
+		title: String(metadata.title ?? '').slice(0, 300),
+		description: String(metadata.description ?? '').slice(0, 1_000),
+		imageUrl: String(metadata.image ?? '').slice(0, 2_000),
+		siteName: String(metadata.publisher ?? new URL(url).hostname).slice(0, 200),
+		provider: '',
+		providerId: ''
+	};
+}
+
+async function providerMetadata(url: string, provider: VideoProvider) {
+	const endpoint =
+		provider === 'youtube'
+			? `https://www.youtube.com/oembed?format=json&url=${encodeURIComponent(url)}`
+			: `https://www.tiktok.com/oembed?url=${encodeURIComponent(url)}`;
+	const response = await requestPublic(endpoint, 'application/json', 256 * 1024);
+	if (!response.contentType.toLowerCase().includes('json')) throw new Error('FETCH_INVALID_TYPE');
+	const value = JSON.parse(response.data.toString('utf8')) as Record<string, unknown>;
+	return {
+		title: String(value.title ?? '').slice(0, 300),
+		description: '',
+		imageUrl: String(value.thumbnail_url ?? '').slice(0, 2_000),
+		siteName: String(value.provider_name ?? (provider === 'youtube' ? 'YouTube' : 'TikTok')).slice(
+			0,
+			200
+		)
+	};
+}
+
+export async function fetchPresentationMetadata(url: string): Promise<PresentationMetadata> {
+	const video = detectVideoProvider(url);
+	if (video) {
+		const metadata = await providerMetadata(url, video.provider);
+		return { ...metadata, provider: video.provider, providerId: video.id };
+	}
+	const response = await requestPublic(url, 'text/html,application/xhtml+xml', MAX_HTML_BYTES);
+	const contentType = response.contentType.toLowerCase();
+	if (!contentType.includes('text/html') && !contentType.includes('application/xhtml+xml')) {
+		throw new Error('FETCH_INVALID_TYPE');
+	}
+	return extractMetadataFromHtml(response.data.toString('utf8'), response.url);
+}
+
+export async function fetchPresentationImage(url: string) {
+	const response = await requestPublic(
+		url,
+		'image/jpeg,image/png,image/webp,image/gif',
+		MAX_IMAGE_BYTES
+	);
+	const mimeType = response.contentType.split(';')[0].trim().toLowerCase();
+	if (!['image/jpeg', 'image/png', 'image/webp', 'image/gif'].includes(mimeType)) {
+		throw new Error('FETCH_INVALID_TYPE');
+	}
+	return { data: response.data, mimeType };
+}

src/lib/server/previews.ts

@@ -86,7 +86,7 @@ export function getPieces(): PreviewPiece[] {
 				(SELECT count(*) FROM piece_sources ps WHERE ps.piece_id = p.id) AS source_count
 			FROM pieces p
 			LEFT JOIN formats f ON f.id = p.format_id
-			WHERE p.status IN ('preparing', 'ready')
+			WHERE p.status IN ('preparing', 'ready') AND p.deleted_at_utc IS NULL
 			ORDER BY CASE p.status WHEN 'ready' THEN 0 ELSE 1 END, p.title`
 		)
 		.all() as PieceRow[];
@@ -175,9 +175,12 @@ export function getTaxonomy() {
 			id: string;
 			name: string;
 		}[],
-		topics: database.prepare('SELECT id, name FROM topics ORDER BY name').all() as {
+		topics: database
+			.prepare('SELECT id, name, icon_name AS iconName FROM topics ORDER BY name')
+			.all() as {
 			id: string;
 			name: string;
+			iconName: string;
 		}[]
 	};
 }

src/lib/server/shows.spec.ts

@@ -9,10 +9,14 @@ import {
 	addPieceUsage,
 	addShowSection,
 	createShow,
+	createAndAddPieceUsage,
+	duplicatePieceUsage,
+	getPieceUsageContexts,
 	getShow,
 	listShowTemplates,
 	movePieceUsage,
 	moveShowSection,
+	refreshPieceUsageFromOriginal,
 	removePieceUsage,
 	removeShowSection,
 	updatePieceUsage,
@@ -41,18 +45,85 @@ function editedUsage(usage: PieceUsage, overrides: Partial<PieceUsage> = {}) {
 	const edited = { ...usage, ...overrides };
 	return {
 		title: edited.title,
+		outputTitle: edited.outputTitle,
 		intro: edited.intro,
 		research: edited.research,
 		moderation: edited.moderation,
 		transition: edited.transition,
 		presentation: edited.presentation,
+		presentationMode: edited.presentationMode,
+		presentationSourceLabel: edited.presentationSourceLabel,
+		presentationSourceUrl: edited.presentationSourceUrl,
+		presentationSourceTimecodeSeconds: edited.presentationSourceTimecodeSeconds,
+		presentationTitle: edited.presentationTitle,
+		presentationDescription: edited.presentationDescription,
+		presentationImageUrl: edited.presentationImageUrl,
+		presentationSiteName: edited.presentationSiteName,
+		presentationMediaId: edited.presentationMediaId,
 		ownNotes: edited.ownNotes,
-		durationSeconds: edited.durationSeconds,
+		durationSeconds: edited.durationSeconds
-		status: edited.status
 	};
 }
 
 describe('show builder data layer', () => {
+	it('creates a fundus original and usage atomically and idempotently', () => {
+		const created = createShow({ title: 'Direkte Planung', startsAtUtc: null, templateId: null });
+		const section = addShowSection(created.id, created.revision, {
+			name: 'Ablauf',
+			categoryId: null,
+			explicitDurationSeconds: null
+		});
+		const before = (
+			getDatabase().prepare('SELECT count(*) AS count FROM pieces').get() as { count: number }
+		).count;
+		const first = createAndAddPieceUsage(created.id, section.revision, 'new-piece-command', {
+			title: 'Direkt geplantes Piece',
+			templateId: 'talk',
+			sectionId: section.id
+		});
+		const repeated = createAndAddPieceUsage(created.id, section.revision, 'new-piece-command', {
+			title: 'Darf nicht doppelt entstehen',
+			templateId: 'blank',
+			sectionId: section.id
+		});
+		expect(repeated).toEqual({ ...first, duplicate: true });
+		expect(getShow(created.id)?.sections[0].usages).toHaveLength(1);
+		expect(getPiece(first.pieceId)).toMatchObject({
+			title: 'Direkt geplantes Piece',
+			status: 'ready',
+			formatId: 'format-talk'
+		});
+		expect(
+			(getDatabase().prepare('SELECT count(*) AS count FROM pieces').get() as { count: number })
+				.count
+		).toBe(before + 1);
+
+		expect(() =>
+			createAndAddPieceUsage(created.id, first.revision, 'failing-command', {
+				title: 'Rollback',
+				templateId: 'blank',
+				sectionId: 'missing'
+			})
+		).toThrow('NOT_FOUND');
+		expect(
+			(getDatabase().prepare('SELECT count(*) AS count FROM pieces').get() as { count: number })
+				.count
+		).toBe(before + 1);
+
+		const removed = removePieceUsage(created.id, first.usageId, first.revision);
+		const afterRemoval = createAndAddPieceUsage(created.id, removed.revision, 'new-piece-command', {
+			title: 'Darf auch nach dem Entfernen nicht neu entstehen',
+			templateId: 'blank',
+			sectionId: section.id
+		});
+		expect(afterRemoval).toEqual({ ...first, duplicate: true });
+		expect(getShow(created.id)?.sections[0].usages).toHaveLength(0);
+		expect(
+			(getDatabase().prepare('SELECT count(*) AS count FROM pieces').get() as { count: number })
+				.count
+		).toBe(before + 1);
+	});
+
 	it('creates blank and templated shows with independent sections and reserve banks', () => {
 		const templatesBefore = listShowTemplates();
 		expect(
@@ -153,6 +224,421 @@ describe('show builder data layer', () => {
 		});
 	});
 
+	it('derives sent history and current planning only from qualifying usages by original id', () => {
+		const completed = createShow({
+			title: 'Abgeschlossene Sendung',
+			startsAtUtc: '2027-01-10T19:00:00Z',
+			templateId: null
+		});
+		const completedSection = addShowSection(completed.id, completed.revision, {
+			name: 'Ablauf',
+			categoryId: null,
+			explicitDurationSeconds: null
+		});
+		const done = addPieceUsage(completed.id, completedSection.revision, {
+			pieceId: 'piece-console',
+			sectionId: completedSection.id
+		});
+		const skipped = addPieceUsage(completed.id, done.revision, {
+			pieceId: 'piece-effects',
+			sectionId: completedSection.id
+		});
+		const reserve = addPieceUsage(completed.id, skipped.revision, {
+			pieceId: 'piece-pixels',
+			sectionId: null
+		});
+		getDatabase()
+			.prepare("UPDATE piece_usages SET status = 'done' WHERE id IN (?, ?)")
+			.run(done.id, reserve.id);
+		getDatabase()
+			.prepare("UPDATE piece_usages SET status = 'skipped' WHERE id = ?")
+			.run(skipped.id);
+		getDatabase().prepare("UPDATE shows SET status = 'completed' WHERE id = ?").run(completed.id);
+
+		const active = createShow({ title: 'Aktuelle Planung', startsAtUtc: null, templateId: null });
+		const activeSection = addShowSection(active.id, active.revision, {
+			name: 'Plan',
+			categoryId: null,
+			explicitDurationSeconds: null
+		});
+		const planned = addPieceUsage(active.id, activeSection.revision, {
+			pieceId: 'piece-console',
+			sectionId: activeSection.id
+		});
+		const plannedReserve = addPieceUsage(active.id, planned.revision, {
+			pieceId: 'piece-effects',
+			sectionId: null
+		});
+		getDatabase().prepare("UPDATE piece_usages SET status = 'done' WHERE id = ?").run(planned.id);
+
+		let contexts = getPieceUsageContexts(
+			['piece-console', 'piece-effects', 'piece-pixels'],
+			active.id
+		);
+		expect(contexts['piece-console']).toMatchObject({
+			isPlannedInCurrentShow: true,
+			sentHistory: [
+				{
+					usageId: done.id,
+					showId: completed.id,
+					showTitle: 'Abgeschlossene Sendung',
+					usedAtUtc: '2027-01-10T19:00:00.000Z'
+				}
+			]
+		});
+		expect(contexts['piece-effects']).toEqual({
+			isPlannedInActiveShow: true,
+			isPlannedInCurrentShow: true,
+			sentHistory: []
+		});
+		expect(contexts['piece-pixels']).toEqual({
+			isPlannedInActiveShow: true,
+			isPlannedInCurrentShow: false,
+			sentHistory: []
+		});
+
+		removePieceUsage(active.id, plannedReserve.id, plannedReserve.revision);
+		contexts = getPieceUsageContexts(['piece-effects'], active.id);
+		expect(contexts['piece-effects'].isPlannedInCurrentShow).toBe(false);
+	});
+
+	it('duplicates an adjusted usage directly after its source without live measurements', () => {
+		const created = createShow({
+			title: 'Einplanungsduplikat',
+			startsAtUtc: null,
+			templateId: null
+		});
+		const section = addShowSection(created.id, created.revision, {
+			name: 'Ablauf',
+			categoryId: null,
+			explicitDurationSeconds: null
+		});
+		const usage = addPieceUsage(created.id, section.revision, {
+			pieceId: 'piece-console',
+			sectionId: section.id
+		});
+		const source = getShow(created.id)!.sections[0].usages[0];
+		const adjusted = updatePieceUsage(
+			created.id,
+			usage.id,
+			usage.revision,
+			editedUsage(source, {
+				title: 'Angepasste Einplanung',
+				durationSeconds: 777,
+				intro: 'Eigene Einleitung',
+				research: 'Eigene Recherche',
+				moderation: 'Eigene Moderation',
+				transition: 'Eigene Überleitung',
+				presentation: 'Eigene Präsentation',
+				ownNotes: 'Eigene Notizen'
+			})
+		);
+		getDatabase().prepare("UPDATE piece_usages SET status = 'done' WHERE id = ?").run(usage.id);
+		getDatabase()
+			.prepare(
+				`INSERT INTO live_usage_runs (id, show_id, usage_id, started_at_utc, ended_at_utc)
+				 VALUES ('source-run', ?, ?, '2027-01-01T10:00:00.000Z', '2027-01-01T10:10:00.000Z')`
+			)
+			.run(created.id, usage.id);
+		const pieceCountBefore = (
+			getDatabase().prepare('SELECT count(*) AS count FROM pieces').get() as { count: number }
+		).count;
+
+		const duplicate = duplicatePieceUsage(created.id, usage.id, adjusted.revision);
+		const usages = getShow(created.id)!.sections[0].usages;
+		expect(usages.map((item) => item.id)).toEqual([usage.id, duplicate.id]);
+		expect(usages[1]).toMatchObject({
+			originalPieceId: 'piece-console',
+			status: 'open',
+			durationSeconds: 777,
+			title: 'Angepasste Einplanung',
+			intro: 'Eigene Einleitung',
+			research: 'Eigene Recherche',
+			moderation: 'Eigene Moderation',
+			transition: 'Eigene Überleitung',
+			presentation: 'Eigene Präsentation',
+			ownNotes: 'Eigene Notizen'
+		});
+		expect(
+			getDatabase()
+				.prepare('SELECT count(*) AS count FROM live_usage_runs WHERE usage_id = ?')
+				.get(duplicate.id)
+		).toEqual({ count: 0 });
+		expect(
+			(getDatabase().prepare('SELECT count(*) AS count FROM pieces').get() as { count: number })
+				.count
+		).toBe(pieceCountBefore);
+
+		getDatabase()
+			.prepare(
+				`UPDATE pieces SET title = 'Aktuelles Original', duration_seconds = 420,
+				 intro = 'Neue Einleitung', research_text = 'Neue Recherche',
+				 moderation_notes = 'Neue Moderation', transition_text = 'Neue Überleitung',
+				 presentation_text = 'Neue Präsentation' WHERE id = 'piece-console'`
+			)
+			.run();
+		const refreshed = refreshPieceUsageFromOriginal(created.id, usage.id, duplicate.revision);
+		const refreshedUsages = getShow(created.id)!.sections[0].usages;
+		expect(refreshedUsages[0]).toMatchObject({
+			title: 'Aktuelles Original',
+			durationSeconds: 420,
+			intro: 'Neue Einleitung',
+			research: 'Neue Recherche',
+			moderation: 'Neue Moderation',
+			transition: 'Neue Überleitung',
+			presentation: 'Neue Präsentation',
+			ownNotes: 'Eigene Notizen',
+			status: 'done'
+		});
+		expect(refreshedUsages[1]).toMatchObject({
+			title: 'Angepasste Einplanung',
+			durationSeconds: 777,
+			status: 'open'
+		});
+		expect(
+			getDatabase()
+				.prepare('SELECT count(*) AS count FROM live_usage_runs WHERE usage_id = ?')
+				.get(usage.id)
+		).toEqual({ count: 1 });
+		expect(() => duplicatePieceUsage(created.id, usage.id, adjusted.revision)).toThrow('CONFLICT');
+		expect(getShow(created.id)?.revision).toBe(refreshed.revision);
+		getDatabase()
+			.prepare('UPDATE piece_usages SET original_piece_id = NULL WHERE id = ?')
+			.run(duplicate.id);
+		expect(() =>
+			refreshPieceUsageFromOriginal(created.id, duplicate.id, refreshed.revision)
+		).toThrow('ORIGINAL_NOT_FOUND');
+		expect(getShow(created.id)?.revision).toBe(refreshed.revision);
+		expect(getShow(created.id)!.sections[0].usages).toHaveLength(2);
+	});
+
+	it('snapshots presentation settings until an explicit refresh and copies them on duplication', () => {
+		getDatabase()
+			.prepare(
+				`UPDATE piece_sources SET label = 'YouTube', url = ?, timecode_seconds = 75
+				 WHERE piece_id = 'piece-console' AND position = 0`
+			)
+			.run('https://youtu.be/dQw4w9WgXcQ');
+		getDatabase()
+			.prepare(
+				`UPDATE pieces SET output_title = 'Öffentlicher Ausgabetitel',
+				 presentation_mode = 'video', presentation_source_position = 0,
+				 presentation_title = 'Gespeicherte Vorschau', presentation_description = 'Erster Stand',
+				 presentation_site_name = 'YouTube', presentation_provider = 'youtube',
+				 presentation_provider_id = 'dQw4w9WgXcQ' WHERE id = 'piece-console'`
+			)
+			.run();
+		const show = createShow({ title: 'Snapshot-Test', startsAtUtc: null, templateId: null });
+		const section = addShowSection(show.id, show.revision, {
+			name: 'Videos',
+			categoryId: null,
+			explicitDurationSeconds: null
+		});
+		const added = addPieceUsage(show.id, section.revision, {
+			pieceId: 'piece-console',
+			sectionId: section.id
+		});
+		let usage = getShow(show.id)!.sections[0].usages[0];
+		expect(usage).toMatchObject({
+			outputTitle: 'Öffentlicher Ausgabetitel',
+			presentationMode: 'video',
+			presentationSourceUrl: 'https://youtu.be/dQw4w9WgXcQ',
+			presentationSourceTimecodeSeconds: 75,
+			presentationTitle: 'Gespeicherte Vorschau'
+		});
+
+		getDatabase()
+			.prepare(
+				`UPDATE pieces SET presentation_title = 'Neuer Originaltitel' WHERE id = 'piece-console'`
+			)
+			.run();
+		expect(getShow(show.id)!.sections[0].usages[0].presentationTitle).toBe('Gespeicherte Vorschau');
+		const refreshed = refreshPieceUsageFromOriginal(show.id, usage.id, added.revision);
+		usage = getShow(show.id)!.sections[0].usages[0];
+		expect(usage.presentationTitle).toBe('Neuer Originaltitel');
+		duplicatePieceUsage(show.id, usage.id, refreshed.revision);
+		expect(getShow(show.id)!.sections[0].usages[1]).toMatchObject({
+			presentationMode: 'video',
+			presentationSourceUrl: 'https://youtu.be/dQw4w9WgXcQ',
+			presentationTitle: 'Neuer Originaltitel',
+			status: 'open'
+		});
+	});
+
+	it('keeps private source, tool and topic snapshots stable until an explicit refresh', () => {
+		const database = getDatabase();
+		database
+			.prepare(
+				`INSERT INTO tools (id, name, start_url, description, is_active, created_at_utc, updated_at_utc)
+				 VALUES ('tool-tierlist', 'Tierlist', 'https://example.com/start', '', 1, ?, ?)`
+			)
+			.run('2026-10-23T00:00:00.000Z', '2026-10-23T00:00:00.000Z');
+		database
+			.prepare(
+				`INSERT INTO piece_tools (id, piece_id, tool_id, work_url, note, position)
+				 VALUES ('piece-tool-console', 'piece-console', 'tool-tierlist', 'https://example.com/board', 'Erster Stand', 0)`
+			)
+			.run();
+		const show = createShow({ title: 'Relationen', startsAtUtc: null, templateId: null });
+		const section = addShowSection(show.id, show.revision, {
+			name: 'Block',
+			categoryId: null,
+			explicitDurationSeconds: null
+		});
+		const added = addPieceUsage(show.id, section.revision, {
+			pieceId: 'piece-console',
+			sectionId: section.id
+		});
+		let usage = getShow(show.id)!.sections[0].usages[0];
+		expect(usage).toMatchObject({
+			sources: [{ label: 'Herstellerseite', url: 'https://example.com/console' }],
+			tools: [{ name: 'Tierlist', workUrl: 'https://example.com/board', note: 'Erster Stand' }],
+			topics: [{ name: 'Gaming', iconName: '' }]
+		});
+
+		database
+			.prepare("UPDATE piece_sources SET label = 'Neue Quelle' WHERE piece_id = 'piece-console'")
+			.run();
+		database
+			.prepare("UPDATE tools SET name = 'Neuer Katalogname' WHERE id = 'tool-tierlist'")
+			.run();
+		database
+			.prepare(
+				"UPDATE piece_tools SET work_url = 'https://example.com/new' WHERE id = 'piece-tool-console'"
+			)
+			.run();
+		database.prepare("DELETE FROM piece_topics WHERE piece_id = 'piece-console'").run();
+		database
+			.prepare(
+				"INSERT INTO piece_topics (piece_id, topic_id) VALUES ('piece-console', 'topic-internet')"
+			)
+			.run();
+		usage = getShow(show.id)!.sections[0].usages[0];
+		expect(usage.sources[0].label).toBe('Herstellerseite');
+		expect(usage.tools[0]).toMatchObject({
+			name: 'Tierlist',
+			workUrl: 'https://example.com/board'
+		});
+		expect(usage.topics).toEqual([{ name: 'Gaming', iconName: '' }]);
+
+		refreshPieceUsageFromOriginal(show.id, usage.id, added.revision);
+		usage = getShow(show.id)!.sections[0].usages[0];
+		expect(usage.sources[0].label).toBe('Neue Quelle');
+		expect(usage.tools[0]).toMatchObject({
+			name: 'Neuer Katalogname',
+			workUrl: 'https://example.com/new'
+		});
+		expect(usage.topics).toEqual([{ name: 'Netzkultur', iconName: '' }]);
+	});
+
+	it('snapshots active media, their presentation choice and topic icons independently', () => {
+		const database = getDatabase();
+		database.prepare("UPDATE topics SET icon_name = 'gamepad' WHERE id = 'topic-gaming'").run();
+		const insertMedia = database.prepare(
+			`INSERT INTO piece_media (id, piece_id, storage_name, original_name, mime_type,
+			 byte_size, alt_text, position, created_at_utc, removed_at_utc)
+			 VALUES (?, 'piece-console', ?, ?, 'image/png', 10, ?, ?, ?, ?)`
+		);
+		insertMedia.run(
+			'media-first',
+			'first.png',
+			'first-original.png',
+			'Erstes Bild',
+			0,
+			'2026-10-23T00:00:00.000Z',
+			null
+		);
+		insertMedia.run(
+			'media-second',
+			'second.png',
+			'second-original.png',
+			'Zweites Bild',
+			1,
+			'2026-10-23T00:00:00.000Z',
+			null
+		);
+		insertMedia.run(
+			'media-removed',
+			'removed.png',
+			'removed-original.png',
+			'Entferntes Bild',
+			2,
+			'2026-10-23T00:00:00.000Z',
+			'2026-10-23T01:00:00.000Z'
+		);
+		database
+			.prepare(
+				"INSERT INTO piece_presentation_media (piece_id, media_id) VALUES ('piece-console', 'media-first')"
+			)
+			.run();
+		const show = createShow({ title: 'Medien', startsAtUtc: null, templateId: null });
+		const section = addShowSection(show.id, show.revision, {
+			name: 'Bilder',
+			categoryId: null,
+			explicitDurationSeconds: null
+		});
+		const added = addPieceUsage(show.id, section.revision, {
+			pieceId: 'piece-console',
+			sectionId: section.id
+		});
+		let usage = getShow(show.id)!.sections[0].usages[0];
+		expect(usage.topics).toEqual([{ name: 'Gaming', iconName: 'gamepad' }]);
+		expect(usage.media).toMatchObject([
+			{ originalMediaId: 'media-first', altText: 'Erstes Bild', position: 0, isPresentation: true },
+			{
+				originalMediaId: 'media-second',
+				altText: 'Zweites Bild',
+				position: 1,
+				isPresentation: false
+			}
+		]);
+		expect(usage.presentationMediaId).toBe(usage.media[0].id);
+
+		const selected = updatePieceUsage(show.id, usage.id, added.revision, {
+			...editedUsage(usage),
+			presentationMediaId: usage.media[1].id
+		});
+		usage = getShow(show.id)!.sections[0].usages[0];
+		expect(usage.media.map((item) => item.isPresentation)).toEqual([false, true]);
+		expect(() =>
+			updatePieceUsage(show.id, usage.id, selected.revision, {
+				...editedUsage(usage),
+				presentationMediaId: 'media-first'
+			})
+		).toThrow('INVALID_PRESENTATION_MEDIA');
+		expect(getShow(show.id)?.revision).toBe(selected.revision);
+
+		const duplicate = duplicatePieceUsage(show.id, usage.id, selected.revision);
+		const duplicateUsage = getShow(show.id)!.sections[0].usages[1];
+		expect(duplicateUsage.media.map((item) => item.originalMediaId)).toEqual([
+			'media-first',
+			'media-second'
+		]);
+		expect(duplicateUsage.presentationMediaId).toBe(duplicateUsage.media[1].id);
+		expect(duplicateUsage.media.map((item) => item.id)).not.toEqual(
+			usage.media.map((item) => item.id)
+		);
+
+		database
+			.prepare("UPDATE piece_media SET removed_at_utc = ? WHERE id = 'media-first'")
+			.run('2026-10-23T02:00:00.000Z');
+		database
+			.prepare("UPDATE piece_media SET alt_text = 'Neuer Alternativtext' WHERE id = 'media-second'")
+			.run();
+		database.prepare("DELETE FROM piece_presentation_media WHERE piece_id = 'piece-console'").run();
+		database
+			.prepare(
+				"INSERT INTO piece_presentation_media (piece_id, media_id) VALUES ('piece-console', 'media-second')"
+			)
+			.run();
+		refreshPieceUsageFromOriginal(show.id, usage.id, duplicate.revision);
+		usage = getShow(show.id)!.sections[0].usages[0];
+		expect(usage.media).toMatchObject([
+			{ originalMediaId: 'media-second', altText: 'Neuer Alternativtext', isPresentation: true }
+		]);
+		expect(duplicateUsage.media).toHaveLength(2);
+	});
+
 	it('persists normalized section and usage reordering, moving and removal', () => {
 		const created = createShow({ title: 'Sortierung', startsAtUtc: null, templateId: null });
 		const firstSection = addShowSection(created.id, created.revision, {

src/lib/server/tools.spec.ts

@@ -0,0 +1,78 @@
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { closeDatabase } from './database.js';
+import { createTool, listTools, updateTool } from './tools.js';
+
+let directory: string;
+
+beforeEach(() => {
+	directory = mkdtempSync(path.join(tmpdir(), 'sendewerk-tools-test-'));
+	process.env.SENDEWERK_DB_PATH = path.join(directory, 'test.sqlite');
+	process.env.SENDEWERK_UPLOAD_DIR = path.join(directory, 'uploads');
+	execFileSync(process.execPath, ['scripts/migrate.mjs'], { cwd: process.cwd(), env: process.env });
+	execFileSync(process.execPath, ['scripts/seed.mjs'], { cwd: process.cwd(), env: process.env });
+});
+
+afterEach(() => {
+	closeDatabase();
+	delete process.env.SENDEWERK_DB_PATH;
+	delete process.env.SENDEWERK_UPLOAD_DIR;
+	rmSync(directory, { recursive: true, force: true });
+});
+
+describe('tool catalog', () => {
+	it('validates, classifies and deactivates tools without deleting them', () => {
+		const id = createTool({
+			name: 'Tierlist',
+			startUrl: 'https://example.com/tierlist',
+			description: 'Gemeinsames Ranking',
+			iconName: 'ranking-star',
+			isActive: true,
+			formatIds: ['format-quiz']
+		});
+		expect(listTools()).toEqual([
+			{
+				id,
+				name: 'Tierlist',
+				startUrl: 'https://example.com/tierlist',
+				description: 'Gemeinsames Ranking',
+				iconName: 'ranking-star',
+				isActive: true,
+				formatIds: ['format-quiz']
+			}
+		]);
+		updateTool(id, {
+			name: 'Tierlist',
+			startUrl: '',
+			description: '',
+			iconName: 'list-ol',
+			isActive: false,
+			formatIds: []
+		});
+		expect(listTools()).toEqual([]);
+		expect(listTools(true)[0]).toMatchObject({ id, iconName: 'list-ol', isActive: false });
+		expect(() =>
+			createTool({
+				name: 'Unsicher',
+				startUrl: 'javascript:alert(1)',
+				description: '',
+				iconName: 'wrench',
+				isActive: true,
+				formatIds: []
+			})
+		).toThrow('INVALID_TOOL_URL');
+		expect(() =>
+			createTool({
+				name: 'Unbekanntes Icon',
+				startUrl: '',
+				description: '',
+				iconName: 'kein-font-awesome-icon',
+				isActive: true,
+				formatIds: []
+			})
+		).toThrow('INVALID_ICON');
+	});
+});

src/lib/server/tools.ts

@@ -0,0 +1,156 @@
+import { randomUUID } from 'node:crypto';
+import { classicRegularIconNames } from '#lib/icons/classic-regular.js';
+import { getDatabase } from './database.js';
+
+export type Tool = {
+	id: string;
+	name: string;
+	startUrl: string;
+	description: string;
+	iconName: string;
+	isActive: boolean;
+	formatIds: string[];
+};
+
+export type ToolInput = Omit<Tool, 'id'>;
+
+function clean(value: unknown, maximum: number, required = false) {
+	const text = String(value ?? '').trim();
+	if (text.length > maximum || (required && !text)) throw new Error('INVALID_TOOL');
+	return text;
+}
+
+function validUrl(value: string) {
+	if (!value) return '';
+	try {
+		const url = new URL(value);
+		if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password)
+			throw new Error();
+		return url.href;
+	} catch {
+		throw new Error('INVALID_TOOL_URL');
+	}
+}
+
+function validated(input: ToolInput): ToolInput {
+	const formatIds = [...new Set(input.formatIds.filter(Boolean))];
+	if (formatIds.length > 30) throw new Error('INVALID_TOOL');
+	if (formatIds.length) {
+		const placeholders = formatIds.map(() => '?').join(', ');
+		const row = getDatabase()
+			.prepare(`SELECT count(*) AS count FROM formats WHERE id IN (${placeholders})`)
+			.get(...formatIds) as { count: number };
+		if (row.count !== formatIds.length) throw new Error('INVALID_TOOL_FORMAT');
+	}
+	return {
+		name: clean(input.name, 120, true),
+		startUrl: validUrl(clean(input.startUrl, 2_000)),
+		description: clean(input.description, 2_000),
+		iconName: (() => {
+			const iconName = clean(input.iconName, 120, true);
+			if (!classicRegularIconNames.has(iconName)) throw new Error('INVALID_ICON');
+			return iconName;
+		})(),
+		isActive: Boolean(input.isActive),
+		formatIds
+	};
+}
+
+export function listTools(includeInactive = false): Tool[] {
+	const database = getDatabase();
+	const rows = database
+		.prepare(
+			`SELECT id, name, start_url, description, icon_name, is_active FROM tools
+			 ${includeInactive ? '' : 'WHERE is_active = 1'} ORDER BY is_active DESC, name`
+		)
+		.all() as {
+		id: string;
+		name: string;
+		start_url: string;
+		description: string;
+		icon_name: string;
+		is_active: number;
+	}[];
+	const formats = database.prepare(
+		'SELECT format_id FROM tool_formats WHERE tool_id = ? ORDER BY format_id'
+	);
+	return rows.map((row) => ({
+		id: row.id,
+		name: row.name,
+		startUrl: row.start_url,
+		description: row.description,
+		iconName: row.icon_name,
+		isActive: row.is_active === 1,
+		formatIds: (formats.all(row.id) as { format_id: string }[]).map((item) => item.format_id)
+	}));
+}
+
+function replaceFormats(toolId: string, formatIds: string[]) {
+	const database = getDatabase();
+	database.prepare('DELETE FROM tool_formats WHERE tool_id = ?').run(toolId);
+	const insert = database.prepare('INSERT INTO tool_formats (tool_id, format_id) VALUES (?, ?)');
+	for (const formatId of formatIds) insert.run(toolId, formatId);
+}
+
+export function createTool(rawInput: ToolInput) {
+	const input = validated(rawInput);
+	const database = getDatabase();
+	const id = randomUUID();
+	const now = new Date().toISOString();
+	try {
+		database.transaction(() => {
+			database
+				.prepare(
+					`INSERT INTO tools (id, name, start_url, description, icon_name, is_active, created_at_utc, updated_at_utc)
+					 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+				)
+				.run(
+					id,
+					input.name,
+					input.startUrl,
+					input.description,
+					input.iconName,
+					input.isActive ? 1 : 0,
+					now,
+					now
+				);
+			replaceFormats(id, input.formatIds);
+		})();
+	} catch (cause) {
+		if (cause instanceof Error && cause.message.includes('UNIQUE')) {
+			throw new Error('TOOL_EXISTS', { cause });
+		}
+		throw cause;
+	}
+	return id;
+}
+
+export function updateTool(id: string, rawInput: ToolInput) {
+	const input = validated(rawInput);
+	const database = getDatabase();
+	try {
+		database.transaction(() => {
+			const result = database
+				.prepare(
+					`UPDATE tools SET name = ?, start_url = ?, description = ?, icon_name = ?, is_active = ?, updated_at_utc = ?
+					 WHERE id = ?`
+				)
+				.run(
+					input.name,
+					input.startUrl,
+					input.description,
+					input.iconName,
+					input.isActive ? 1 : 0,
+					new Date().toISOString(),
+					id
+				);
+			if (result.changes !== 1) throw new Error('NOT_FOUND');
+			replaceFormats(id, input.formatIds);
+		})();
+	} catch (cause) {
+		if (cause instanceof Error && cause.message.includes('UNIQUE')) {
+			throw new Error('TOOL_EXISTS', { cause });
+		}
+		throw cause;
+	}
+}

src/routes/+layout.server.ts

@@ -1,3 +1,6 @@
 import type { LayoutServerLoad } from './$types';
 
-export const load: LayoutServerLoad = ({ locals }) => ({ user: locals.user });
+export const load: LayoutServerLoad = ({ locals, url }) => ({
+	user: url.pathname.startsWith('/heinzlive/') ? null : locals.user,
+	presentationMode: url.pathname.startsWith('/heinzlive/')
+});

src/routes/+layout.svelte

@@ -3,6 +3,7 @@
 	import { resolve } from '$app/paths';
 	import { page } from '$app/state';
 	import NavIcon from '#lib/components/NavIcon.svelte';
+	import AppIcon from '#lib/components/AppIcon.svelte';
 	import ThemeToggle from '#lib/components/ThemeToggle.svelte';
 
 	let { children, data } = $props();
@@ -31,7 +32,9 @@
 	/>
 </svelte:head>
 
-{#if data.user}
+{#if data.presentationMode}
+	{@render children()}
+{:else if data.user}
 	<div class="app-shell">
 		<aside class="sidebar">
 			<a class="brand" href={resolve('/fundus')} aria-label="Sendewerk Startseite">
@@ -82,7 +85,9 @@
 				<span>Sendewerk</span>
 			</a>
 			<form method="POST" action="/logout">
-				<button class="mobile-logout" type="submit" aria-label="Abmelden">↗</button>
+				<button class="mobile-logout" type="submit" aria-label="Abmelden"
+					><AppIcon name="right-from-bracket" /></button
+				>
 			</form>
 			<ThemeToggle />
 		</header>

src/routes/archiv/+page.server.ts

@@ -1,11 +1,17 @@
 import { fail } from '@sveltejs/kit';
 import type { Actions, PageServerLoad } from './$types';
 import { requireUser } from '#lib/server/auth.js';
-import { listPieces, setPieceArchived } from '#lib/server/content.js';
+import { listPieces, setPieceArchived, setPieceDeleted } from '#lib/server/content.js';
 
 export const load: PageServerLoad = ({ locals }) => {
 	requireUser(locals.user);
-	return { pieces: listPieces({ statuses: ['archived'] }) };
+	return {
+		pieces: listPieces({ statuses: ['archived'] }),
+		deletedPieces: listPieces({
+			statuses: ['inbox', 'preparing', 'ready', 'archived'],
+			deleted: true
+		})
+	};
 };
 
 export const actions = {
@@ -18,5 +24,15 @@ export const actions = {
 		} catch {
 			return fail(409, { error: 'Das Piece wurde inzwischen geändert. Bitte Seite neu laden.' });
 		}
+	},
+	restoreDeleted: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		try {
+			setPieceDeleted(String(data.get('pieceId') || ''), Number(data.get('revision')), false);
+			return { success: 'Gelöschtes Piece wurde wiederhergestellt.' };
+		} catch {
+			return fail(409, { error: 'Das Piece wurde inzwischen geändert. Bitte Seite neu laden.' });
+		}
 	}
 } satisfies Actions;

src/routes/archiv/+page.svelte

@@ -1,4 +1,5 @@
 <script lang="ts">
+	import AppIcon from '#lib/components/AppIcon.svelte';
 	import type { PageProps } from './$types';
 	let { data, form }: PageProps = $props();
 </script>
@@ -28,8 +29,29 @@
 				</article>{/each}
 		</div>
 	{:else}<section class="quiet-panel planned-panel">
-			<div class="planned-icon" aria-hidden="true">□</div>
+			<div class="planned-icon" aria-hidden="true"><AppIcon name="box-archive" /></div>
 			<h2>Keine Pieces archiviert</h2>
 			<p>Archivierte Inhalte lassen sich hier später wiederherstellen.</p>
 		</section>{/if}
+	<section class="deleted-pieces" aria-labelledby="deleted-pieces-title">
+		<h2 id="deleted-pieces-title">Gelöschte Pieces</h2>
+		<p class="quiet-copy">
+			Diese Einträge bleiben wiederherstellbar; bestehende Sendungsfassungen werden nicht verändert.
+		</p>
+		{#if data.deletedPieces.length}<div class="archive-list">
+				{#each data.deletedPieces as piece (piece.id)}<article>
+						<div>
+							<h2>{piece.title}</h2>
+							{#if piece.summary}<p>{piece.summary}</p>{/if}
+						</div>
+						<form method="POST" action="?/restoreDeleted">
+							<input type="hidden" name="pieceId" value={piece.id} /><input
+								type="hidden"
+								name="revision"
+								value={piece.revision}
+							/><button class="secondary-button" type="submit">Wiederherstellen</button>
+						</form>
+					</article>{/each}
+			</div>{:else}<p class="context-empty">Keine gelöschten Pieces.</p>{/if}
+	</section>
 </div>

src/routes/eingang/+page.server.ts

@@ -1,7 +1,7 @@
-import { fail, redirect } from '@sveltejs/kit';
+import { fail } from '@sveltejs/kit';
 import type { Actions, PageServerLoad } from './$types';
 import { requireUser } from '#lib/server/auth.js';
-import { captureInbox, listPieces } from '#lib/server/content.js';
+import { captureInbox, listPieces, setPieceDeleted } from '#lib/server/content.js';
 
 export const load: PageServerLoad = ({ locals }) => {
 	requireUser(locals.user);
@@ -14,7 +14,7 @@ export const actions = {
 		const data = await request.formData();
 		try {
 			const id = captureInbox(String(data.get('title') || ''), String(data.get('url') || ''));
-			redirect(303, `/fundus/${id}`);
+			return { captured: true, capturedId: id };
 		} catch (cause) {
 			const code = cause instanceof Error ? cause.message : '';
 			return fail(400, {
@@ -26,5 +26,15 @@ export const actions = {
 						: 'Ein Titel ist erforderlich.'
 			});
 		}
+	},
+	delete: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		try {
+			setPieceDeleted(String(data.get('pieceId') || ''), Number(data.get('revision')), true);
+			return { deleted: true };
+		} catch {
+			return fail(409, { error: 'Das Piece wurde inzwischen geändert. Bitte neu laden.' });
+		}
 	}
 } satisfies Actions;

src/routes/eingang/+page.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
 	import { resolve } from '$app/paths';
+	import AppIcon from '#lib/components/AppIcon.svelte';
 	import type { PageProps } from './$types';
 	let { data, form }: PageProps = $props();
 </script>
@@ -17,11 +18,14 @@
 			<h2>Was soll nicht verloren gehen?</h2>
 		</div>
 		{#if form?.error}<div class="form-message error" role="alert">{form.error}</div>{/if}
+		{#if form?.captured}<div class="form-message success" role="status">
+				Im Eingang gespeichert.
+				<a href={resolve('/fundus/[id]', { id: form.capturedId })}>Jetzt ausarbeiten</a>
+			</div>{/if}
 		<form method="POST" action="?/capture" class="capture-form">
 			<label
-				>Titel oder Gedanke<input
+				>Gedanke <span>optional bei URL</span><input
 					name="title"
-					required
 					maxlength="200"
 					value={form?.title ?? ''}
 					placeholder="Kurze Idee festhalten"
@@ -36,24 +40,43 @@
 					placeholder="https://…"
 				/></label
 			>
-			<button class="primary-button" type="submit">Aufnehmen und öffnen</button>
+			<button class="primary-button" type="submit">Im Eingang ablegen</button>
 		</form>
 	</section>
 	{#if data.pieces.length}
 		<section class="inbox-list">
 			<h2>{data.pieces.length} {data.pieces.length === 1 ? 'offener Inhalt' : 'offene Inhalte'}</h2>
-			{#each data.pieces as piece (piece.id)}<a
+			{#each data.pieces as piece (piece.id)}<article class="inbox-item">
-					class="inbox-item"
+					<a href={resolve('/fundus/[id]', { id: piece.id })}
-					href={resolve('/fundus/[id]', { id: piece.id })}
+						><span
-					><span
+							><strong>{piece.title}</strong><small
-						><strong>{piece.title}</strong><small
+								>{piece.sourceCount ? `${piece.sourceCount} Quelle` : 'Gedanke ohne Link'}</small
-							>{piece.sourceCount ? `${piece.sourceCount} Quelle` : 'Gedanke ohne Link'}</small
+							></span
-						></span
+						><span>Ausarbeiten <AppIcon name="arrow-right" /></span></a
-					><span>Ausarbeiten →</span></a
+					>
-				>{/each}
+					<details class="piece-actions">
+						<summary aria-label={`Aktionen für ${piece.title}`}><AppIcon name="ellipsis" /></summary
+						>
+						<div class="piece-actions-popover">
+							<form
+								method="POST"
+								action="?/delete"
+								onsubmit={(event) =>
+									!confirm(`„${piece.title}“ löschen?`) && event.preventDefault()}
+							>
+								<input type="hidden" name="pieceId" value={piece.id} /><input
+									type="hidden"
+									name="revision"
+									value={piece.revision}
+								/>
+								<button class="text-button danger-text" type="submit">Piece löschen</button>
+							</form>
+						</div>
+					</details>
+				</article>{/each}
 		</section>
 	{:else}<section class="quiet-panel planned-panel">
-			<div class="planned-icon" aria-hidden="true">＋</div>
+			<div class="planned-icon" aria-hidden="true"><AppIcon name="plus" /></div>
 			<h2>Eingang ist leer</h2>
 			<p>Neue Gedanken und Links können oben direkt aufgenommen werden.</p>
 		</section>{/if}

src/routes/fundus/+page.server.ts

@@ -3,13 +3,16 @@ import type { Actions, PageServerLoad } from './$types';
 import { requireUser } from '#lib/server/auth.js';
 import {
 	createPiece,
+	deletePieceTemplate,
 	duplicatePiece,
 	getTaxonomy,
 	listPieces,
-	pieceTemplates,
+	listPieceTemplates,
 	setPieceArchived,
-	type PieceTemplateId
+	setPieceDeleted,
+	setPieceFavorite
 } from '#lib/server/content.js';
+import { getPieceUsageContexts } from '#lib/server/shows.js';
 
 export const load: PageServerLoad = ({ locals, url }) => {
 	requireUser(locals.user);
@@ -18,23 +21,27 @@ export const load: PageServerLoad = ({ locals, url }) => {
 		formatId: url.searchParams.get('format') ?? '',
 		topicId: url.searchParams.get('topic') ?? '',
 		categoryId: url.searchParams.get('category') ?? '',
-		status: url.searchParams.get('status') ?? ''
+		status: url.searchParams.get('status') ?? '',
+		includeUsed: url.searchParams.get('includeUsed') === '1',
+		includePlanned: url.searchParams.get('includePlanned') === '1'
 	};
+	const pieces = listPieces({
+		statuses:
+			filters.status === 'ready'
+				? ['ready']
+				: filters.status === 'preparing'
+					? ['preparing']
+					: ['preparing', 'ready'],
+		query: filters.query,
+		formatId: filters.formatId,
+		topicId: filters.topicId,
+		categoryId: filters.categoryId
+	});
+	const usageContexts = getPieceUsageContexts(pieces.map((piece) => piece.id));
 	return {
-		pieces: listPieces({
+		pieces: pieces.map((piece) => ({ ...piece, ...usageContexts[piece.id] })),
-			statuses:
-				filters.status === 'ready'
-					? ['ready']
-					: filters.status === 'preparing'
-						? ['preparing']
-						: ['preparing', 'ready'],
-			query: filters.query,
-			formatId: filters.formatId,
-			topicId: filters.topicId,
-			categoryId: filters.categoryId
-		}),
 		taxonomy: getTaxonomy(),
-		templates: pieceTemplates,
+		templates: listPieceTemplates(),
 		filters
 	};
 };
@@ -52,12 +59,22 @@ export const actions = {
 		const data = await request.formData();
 		let id: string;
 		try {
-			id = createPiece(String(data.get('template') || 'blank') as PieceTemplateId);
+			id = createPiece(String(data.get('template') || 'blank'));
 		} catch (cause) {
 			return fail(400, { intent: 'create', error: actionError(cause) });
 		}
 		redirect(303, `/fundus/${id}`);
 	},
+	deleteTemplate: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		try {
+			deletePieceTemplate(String(data.get('templateId') || ''), Number(data.get('revision')));
+			return { intent: 'deleteTemplate', success: 'Vorlage gelöscht.' };
+		} catch (cause) {
+			return fail(409, { intent: 'deleteTemplate', error: actionError(cause) });
+		}
+	},
 	duplicate: async ({ locals, request }) => {
 		requireUser(locals.user);
 		const data = await request.formData();
@@ -78,5 +95,28 @@ export const actions = {
 		} catch (cause) {
 			return fail(409, { intent: 'archive', error: actionError(cause) });
 		}
+	},
+	favorite: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		try {
+			setPieceFavorite(String(data.get('pieceId') || ''), data.get('favorite') === '1');
+			return { intent: 'favorite', success: 'Favorit aktualisiert.' };
+		} catch (cause) {
+			return fail(404, { intent: 'favorite', error: actionError(cause) });
+		}
+	},
+	delete: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		try {
+			setPieceDeleted(String(data.get('pieceId') || ''), Number(data.get('revision')), true);
+			return {
+				intent: 'delete',
+				success: 'Piece gelöscht. Bestehende Sendungsfassungen bleiben erhalten.'
+			};
+		} catch (cause) {
+			return fail(409, { intent: 'delete', error: actionError(cause) });
+		}
 	}
 } satisfies Actions;

src/routes/fundus/+page.svelte

@@ -1,9 +1,50 @@
 <script lang="ts">
+	import { enhance } from '$app/forms';
+	import { goto, replaceState } from '$app/navigation';
 	import { resolve } from '$app/paths';
+	import { page } from '$app/state';
+	import { onMount, untrack } from 'svelte';
+	import PieceUsageHistory from '#lib/components/PieceUsageHistory.svelte';
+	import AppIcon from '#lib/components/AppIcon.svelte';
 	import { formatClock } from '#lib/format.js';
 	import type { PageProps } from './$types';
 
 	let { data, form }: PageProps = $props();
+	let showUsedPieces = $state(untrack(() => data.filters.includeUsed));
+	let showPlannedPieces = $state(untrack(() => data.filters.includePlanned));
+	let visiblePieces = $derived(
+		data.pieces.filter(
+			(piece) =>
+				(showUsedPieces || piece.sentHistory.length === 0 || piece.isFavorite) &&
+				(showPlannedPieces || !piece.isPlannedInActiveShow)
+		)
+	);
+	onMount(() => {
+		const syncFiltersFromHistory = () => {
+			const search = new URL(window.location.href).searchParams;
+			showUsedPieces = search.get('includeUsed') === '1';
+			showPlannedPieces = search.get('includePlanned') === '1';
+		};
+		window.addEventListener('popstate', syncFiltersFromHistory);
+		return () => window.removeEventListener('popstate', syncFiltersFromHistory);
+	});
+
+	function setSourceFilter(name: 'includeUsed' | 'includePlanned', checked: boolean) {
+		if (name === 'includeUsed') showUsedPieces = checked;
+		else showPlannedPieces = checked;
+		const url = new URL(page.url.href);
+		if (checked) url.searchParams.set(name, '1');
+		else url.searchParams.delete(name);
+		// This URL is cloned from the current page; only same-route filter parameters change.
+		// eslint-disable-next-line svelte/no-navigation-without-resolve
+		replaceState(url, page.state);
+	}
+
+	async function resetFilters() {
+		await goto(resolve('/fundus'), { invalidateAll: true });
+		showUsedPieces = false;
+		showPlannedPieces = false;
+	}
 	const statusLabel = {
 		ready: 'Sendefertig',
 		preparing: 'In Vorbereitung',
@@ -20,132 +61,228 @@
 			<h1>Fundus</h1>
 			<p class="page-intro">Vorbereitete Inhalte für kommende Sendungen.</p>
 		</div>
-		<div class="heading-stat" aria-label={`${data.pieces.length} gefundene Inhalte`}>
+		<div class="fundus-heading-actions">
-			<strong>{data.pieces.length}</strong><span>Inhalte</span>
+			<div class="heading-stat" aria-label={`${visiblePieces.length} gefundene Inhalte`}>
+				<strong>{visiblePieces.length}</strong><span>Inhalte</span>
+			</div>
+			<details class="template-picker">
+				<summary><AppIcon name="plus" /> Neues Piece</summary>
+				<div class="template-popover">
+					<div class="template-grid">
+						{#each data.templates as template (template.id)}
+							<form method="POST" action="?/create">
+								<input type="hidden" name="template" value={template.id} />
+								<button type="submit"
+									><AppIcon name={template.iconName} size="1.35rem" /><strong
+										>{template.name}</strong
+									><span>{template.description}</span></button
+								>
+							</form>
+						{/each}
+					</div>
+					{#if data.templates.some((template) => template.id !== 'blank')}<details
+							class="template-management"
+						>
+							<summary>Vorlagen verwalten</summary>
+							{#each data.templates.filter((template) => template.id !== 'blank') as template (template.id)}
+								<form
+									method="POST"
+									action="?/deleteTemplate"
+									onsubmit={(event) =>
+										!confirm(`Vorlage „${template.name}“ löschen?`) && event.preventDefault()}
+								>
+									<input type="hidden" name="templateId" value={template.id} />
+									<input type="hidden" name="revision" value={template.revision} />
+									<span>{template.name}</span>
+									<button class="text-button danger-text" type="submit">Löschen</button>
+								</form>
+							{/each}
+						</details>{/if}
+				</div>
+			</details>
 		</div>
 	</header>
 	{#if form?.error}<div class="form-message error" role="alert">{form.error}</div>{/if}
 	{#if form?.success}<div class="form-message success" role="status">{form.success}</div>{/if}
 
-	<details class="template-picker">
+	<form
-		<summary>Neues Piece anlegen</summary>
+		id="library-filters"
-		<div class="template-grid">
+		class="library-filters"
-			{#each data.templates as template (template.id)}
+		method="GET"
-				<form method="POST" action="?/create">
+		aria-label="Fundus durchsuchen und filtern"
-					<input type="hidden" name="template" value={template.id} />
+	>
-					<button type="submit"
+		<div class="fundus-search-row">
-						><strong>{template.name}</strong><span>{template.description}</span></button
+			<label class="search-field"
+				><AppIcon name="magnifying-glass" /><span class="sr-only">Fundus durchsuchen</span><input
+					name="q"
+					type="search"
+					value={data.filters.query}
+					placeholder="Titel, Quelle oder Thema suchen"
+				/></label
+			>
+			<button class="secondary-button" type="submit">Suchen</button>
+			<details class="filter-picker">
+				<summary><AppIcon name="list-check" /> Weitere Filter</summary>
+				<div class="filter-panel">
+					<label
+						><span>Status</span><select name="status"
+							><option value="">Alle</option><option
+								value="ready"
+								selected={data.filters.status === 'ready'}>Sendefertig</option
+							><option value="preparing" selected={data.filters.status === 'preparing'}
+								>In Arbeit</option
+							></select
+						></label
 					>
-				</form>
+					<label
-			{/each}
+						><span>Format</span><select name="format"
+							><option value="">Alle</option>{#each data.taxonomy.formats as item (item.id)}<option
+									value={item.id}
+									selected={data.filters.formatId === item.id}>{item.name}</option
+								>{/each}</select
+						></label
+					>
+					<label
+						><span>Thema</span><select name="topic"
+							><option value="">Alle</option>{#each data.taxonomy.topics as item (item.id)}<option
+									value={item.id}
+									selected={data.filters.topicId === item.id}>{item.name}</option
+								>{/each}</select
+						></label
+					>
+					<label
+						><span>Abschnitt</span><select name="category"
+							><option value="">Alle</option
+							>{#each data.taxonomy.categories as item (item.id)}<option
+									value={item.id}
+									selected={data.filters.categoryId === item.id}>{item.name}</option
+								>{/each}</select
+						></label
+					>
+					<div class="library-filter-options" aria-label="Fundusauswahl erweitern">
+						<label class="filter-checkbox">
+							<input
+								type="checkbox"
+								name="includeUsed"
+								value="1"
+								checked={showUsedPieces}
+								onchange={(event) => setSourceFilter('includeUsed', event.currentTarget.checked)}
+							/>
+							<span>Auch verwendete Inhalte zeigen</span>
+						</label>
+						<label class="filter-checkbox">
+							<input
+								type="checkbox"
+								name="includePlanned"
+								value="1"
+								checked={showPlannedPieces}
+								onchange={(event) => setSourceFilter('includePlanned', event.currentTarget.checked)}
+							/>
+							<span>Auch eingeplante Inhalte zeigen</span>
+						</label>
+					</div>
+					<div class="filter-actions">
+						<button class="secondary-button" type="submit">Filter anwenden</button>
+						<button class="text-button" type="button" onclick={resetFilters}>Zurücksetzen</button>
+					</div>
+				</div>
+			</details>
 		</div>
-	</details>
-
-	<form class="library-filters" method="GET" aria-label="Fundus durchsuchen und filtern">
-		<label class="search-field"
-			><span aria-hidden="true">⌕</span><span class="sr-only">Fundus durchsuchen</span><input
-				name="q"
-				type="search"
-				value={data.filters.query}
-				placeholder="Titel, Quelle oder Thema suchen"
-			/></label
-		>
-		<label
-			><span>Status</span><select name="status"
-				><option value="">Alle</option><option
-					value="ready"
-					selected={data.filters.status === 'ready'}>Sendefertig</option
-				><option value="preparing" selected={data.filters.status === 'preparing'}>In Arbeit</option
-				></select
-			></label
-		>
-		<label
-			><span>Format</span><select name="format"
-				><option value="">Alle</option>{#each data.taxonomy.formats as item (item.id)}<option
-						value={item.id}
-						selected={data.filters.formatId === item.id}>{item.name}</option
-					>{/each}</select
-			></label
-		>
-		<label
-			><span>Thema</span><select name="topic"
-				><option value="">Alle</option>{#each data.taxonomy.topics as item (item.id)}<option
-						value={item.id}
-						selected={data.filters.topicId === item.id}>{item.name}</option
-					>{/each}</select
-			></label
-		>
-		<label
-			><span>Abschnitt</span><select name="category"
-				><option value="">Alle</option>{#each data.taxonomy.categories as item (item.id)}<option
-						value={item.id}
-						selected={data.filters.categoryId === item.id}>{item.name}</option
-					>{/each}</select
-			></label
-		>
-		<button class="secondary-button" type="submit">Anwenden</button>
-		<a class="text-link" href={resolve('/fundus')}>Zurücksetzen</a>
 	</form>
 
-	{#if data.pieces.length}
+	{#if visiblePieces.length}
 		<div class="piece-grid">
-			{#each data.pieces as piece (piece.id)}
+			{#each visiblePieces as piece (piece.id)}
 				<article
 					class="piece-card"
 					style={`--category: ${piece.categories[0]?.color ?? '#8b8f98'}`}
 				>
+					<form method="POST" action="?/favorite" class="piece-favorite-form" use:enhance>
+						<input type="hidden" name="pieceId" value={piece.id} />
+						<input type="hidden" name="favorite" value={piece.isFavorite ? '0' : '1'} />
+						<button
+							class="piece-favorite"
+							class:active={piece.isFavorite}
+							type="submit"
+							aria-label={piece.isFavorite
+								? `${piece.title} aus Favoriten entfernen`
+								: `${piece.title} als Favorit markieren`}
+							aria-pressed={piece.isFavorite}><AppIcon name="star" /></button
+						>
+					</form>
 					{#if piece.mediaId}<img
 							class="piece-thumbnail"
 							src={`/media/${piece.mediaId}`}
 							alt=""
-						/>{:else}<span class="piece-thumbnail piece-thumbnail-placeholder" aria-hidden="true"
+						/>{:else}<span class="piece-thumbnail piece-thumbnail-placeholder" aria-hidden="true">
-							>S</span
+							<AppIcon name={piece.topics[0]?.iconName || 'newspaper'} size="2rem" />
-						>{/if}
+						</span>{/if}
 					<div class="piece-primary">
 						<h2><a href={resolve('/fundus/[id]', { id: piece.id })}>{piece.title}</a></h2>
-						<p>{piece.summary || 'Noch keine Kurzbeschreibung.'}</p>
+						{#if piece.summary}<p>{piece.summary}</p>{/if}
+						<PieceUsageHistory history={piece.sentHistory} />
 					</div>
 					<div class="piece-classification">
 						<span class="category-label"
 							><i></i>{piece.categories.map((item) => item.name).join(', ') || 'Offen'}</span
 						>
 						<div class="piece-tags">
-							<span>{piece.format}</span>{#each piece.topics as topic (topic.id)}<span
+							{#if piece.formatId}<span>{piece.format}</span
-									>{topic.name}</span
+								>{/if}{#each piece.topics as topic (topic.id)}<span>{topic.name}</span>{/each}
-								>{/each}
 						</div>
 					</div>
 					<div class="piece-state">
 						<span class:ready={piece.status === 'ready'} class="status-label"
 							>{statusLabel[piece.status]}</span
-						><span class="piece-facts"
+						>{#if piece.durationSeconds || piece.sourceCount}<span class="piece-facts"
-							><span><b>{formatClock(piece.durationSeconds)}</b> geplant</span><span
+								>{#if piece.durationSeconds}<span
-								>{piece.sourceCount} {piece.sourceCount === 1 ? 'Quelle' : 'Quellen'}</span
+										><b>{formatClock(piece.durationSeconds)}</b> geplant</span
-							></span
+									>{/if}{#if piece.sourceCount}<span
+										>{piece.sourceCount} {piece.sourceCount === 1 ? 'Quelle' : 'Quellen'}</span
+									>{/if}</span
+							>{/if}
 						>
 					</div>
-					<div class="piece-actions">
+					<details class="piece-actions">
-						<a class="text-link" href={resolve('/fundus/[id]', { id: piece.id })}>Bearbeiten</a>
+						<summary aria-label={`Aktionen für ${piece.title}`}><AppIcon name="ellipsis" /></summary
-						<form method="POST" action="?/duplicate">
+						>
-							<input type="hidden" name="pieceId" value={piece.id} /><button
+						<div class="piece-actions-popover">
-								class="text-button"
+							<form method="POST" action="?/duplicate">
-								type="submit">Duplizieren</button
+								<input type="hidden" name="pieceId" value={piece.id} /><button
+									class="text-button"
+									type="submit">Duplizieren</button
+								>
+							</form>
+							<form method="POST" action="?/archive">
+								<input type="hidden" name="pieceId" value={piece.id} /><input
+									type="hidden"
+									name="revision"
+									value={piece.revision}
+								/><button class="text-button danger-text" type="submit">Archivieren</button>
+							</form>
+							<form
+								method="POST"
+								action="?/delete"
+								onsubmit={(event) =>
+									!confirm(
+										`Piece „${piece.title}“ löschen? Bestehende Sendungsfassungen bleiben erhalten.`
+									) && event.preventDefault()}
 							>
-						</form>
+								<input type="hidden" name="pieceId" value={piece.id} /><input
-						<form method="POST" action="?/archive">
+									type="hidden"
-							<input type="hidden" name="pieceId" value={piece.id} /><input
+									name="revision"
-								type="hidden"
+									value={piece.revision}
-								name="revision"
+								/>
-								value={piece.revision}
+								<button class="text-button danger-text" type="submit">Piece löschen</button>
-							/><button class="text-button danger-text" type="submit">Archivieren</button>
+							</form>
-						</form>
+						</div>
-					</div>
+					</details>
 				</article>
 			{/each}
 		</div>
 	{:else}
 		<div class="empty-state">
-			<span aria-hidden="true">⌕</span>
+			<span aria-hidden="true"><AppIcon name="magnifying-glass" /></span>
 			<h2>Kein passendes Piece</h2>
 			<p>Andere Filter wählen oder ein neues Piece anlegen.</p>
 			<a class="secondary-button" href={resolve('/fundus')}>Filter zurücksetzen</a>

src/routes/fundus/[id]/+page.server.ts

@@ -6,14 +6,20 @@ import {
 	duplicatePiece,
 	getPiece,
 	getTaxonomy,
+	listPieceTemplates,
+	loadPiecePresentationMetadata,
 	savePiece,
+	savePieceAsTemplate,
 	setPieceArchived,
+	setPieceDeleted,
+	setPieceFavorite,
 	uploadPieceImage,
 	type EditablePieceStatus,
 	type PieceInput,
 	type PieceSourceInput
 } from '#lib/server/content.js';
 import { renderMarkdown } from '#lib/server/markdown.js';
+import { listTools } from '#lib/server/tools.js';
 
 function renderedFields(
 	piece: Pick<
@@ -54,8 +60,12 @@ function pieceInput(data: FormData): PieceInput {
 			timecodeSeconds: timecode ? Number(timecode) : null
 		});
 	}
+	const toolIds = data.getAll('toolId').map(String);
+	const toolWorkUrls = data.getAll('toolWorkUrl').map(String);
+	const toolNotes = data.getAll('toolNote').map(String);
 	return {
 		title: text(data, 'title'),
+		outputTitle: text(data, 'outputTitle'),
 		summary: text(data, 'summary'),
 		formatId: text(data, 'formatId') || null,
 		status: text(data, 'status') as EditablePieceStatus,
@@ -65,9 +75,29 @@ function pieceInput(data: FormData): PieceInput {
 		moderationNotes: text(data, 'moderationNotes'),
 		transitionText: text(data, 'transitionText'),
 		presentationText: text(data, 'presentationText'),
+		presentationMode: text(data, 'presentationMode') as PieceInput['presentationMode'],
+		presentationSourcePosition: text(data, 'presentationSourcePosition')
+			? Number(data.get('presentationSourcePosition'))
+			: null,
+		presentationTitle: text(data, 'presentationTitle'),
+		presentationDescription: text(data, 'presentationDescription'),
+		presentationImageUrl: text(data, 'presentationImageUrl'),
+		presentationSiteName: text(data, 'presentationSiteName'),
+		presentationProvider: text(data, 'presentationProvider'),
+		presentationProviderId: text(data, 'presentationProviderId'),
+		presentationTitleManual: text(data, 'presentationTitleManual') === '1',
+		presentationDescriptionManual: text(data, 'presentationDescriptionManual') === '1',
+		presentationImageManual: text(data, 'presentationImageManual') === '1',
+		presentationMetadataFetchedAtUtc: text(data, 'presentationMetadataFetchedAtUtc') || null,
+		presentationMediaId: text(data, 'presentationMediaId') || null,
 		topicIds: data.getAll('topicIds').map(String),
 		categoryIds: data.getAll('categoryIds').map(String),
-		sources
+		sources,
+		tools: toolIds.map((toolId, index) => ({
+			toolId,
+			workUrl: toolWorkUrls[index] ?? '',
+			note: toolNotes[index] ?? ''
+		}))
 	};
 }
 
@@ -87,6 +117,11 @@ function saveError(cause: unknown) {
 			status: 400,
 			error: 'Quellen benötigen einen Namen und eine vollständige HTTP- oder HTTPS-Adresse.'
 		};
+	if (code === 'INVALID_PRESENTATION')
+		return {
+			status: 400,
+			error: 'Für Linkvorschau und Video muss eine vorhandene gültige Quelle ausgewählt sein.'
+		};
 	if (code.startsWith('INVALID_'))
 		return { status: 400, error: 'Mindestens ein Feld ist ungültig oder zu lang.' };
 	return {
@@ -100,7 +135,13 @@ export const load: PageServerLoad = ({ locals, params }) => {
 	const piece = getPiece(params.id);
 	if (!piece) error(404, 'Piece nicht gefunden');
 	if (piece.status === 'archived') redirect(303, '/archiv');
-	return { piece, taxonomy: getTaxonomy(), rendered: renderedFields(piece) };
+	return {
+		piece,
+		taxonomy: getTaxonomy(),
+		tools: listTools(true),
+		templates: listPieceTemplates().filter((template) => template.id !== 'blank'),
+		rendered: renderedFields(piece)
+	};
 };
 
 export const actions = {
@@ -116,6 +157,50 @@ export const actions = {
 			return fail(problem.status, { intent: 'save', ...problem });
 		}
 	},
+	loadPreview: async ({ locals, params, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		try {
+			await loadPiecePresentationMetadata(params.id, Number(data.get('revision')));
+		} catch (cause) {
+			const code = cause instanceof Error ? cause.message : '';
+			if (code === 'FETCH_BLOCKED') {
+				return fail(400, {
+					intent: 'loadPreview',
+					error: 'Interne oder private Netzwerkziele dürfen nicht abgerufen werden.'
+				});
+			}
+			if (code.startsWith('FETCH_')) {
+				return fail(400, {
+					intent: 'loadPreview',
+					error:
+						'Die Vorschau konnte nicht sicher geladen werden. Die manuellen Angaben bleiben erhalten.'
+				});
+			}
+			const problem = saveError(cause);
+			return fail(problem.status, { intent: 'loadPreview', ...problem });
+		}
+		redirect(303, `/fundus/${params.id}`);
+	},
+	saveTemplate: async ({ locals, params, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		const reference = text(data, 'templateRef');
+		const [templateId, revision] = reference.split('|');
+		try {
+			savePieceAsTemplate(
+				params.id,
+				text(data, 'templateName'),
+				text(data, 'templateDescription'),
+				templateId || undefined,
+				revision ? Number(revision) : undefined
+			);
+			return { intent: 'saveTemplate', success: 'Vorlage gespeichert.' };
+		} catch (cause) {
+			const problem = saveError(cause);
+			return fail(problem.status, { intent: 'saveTemplate', ...problem });
+		}
+	},
 	upload: async ({ locals, params, request }) => {
 		requireUser(locals.user);
 		const data = await request.formData();
@@ -123,7 +208,13 @@ export const actions = {
 		if (!(image instanceof File))
 			return fail(400, { intent: 'upload', error: 'Bitte ein Bild auswählen.' });
 		try {
-			await uploadPieceImage(params.id, Number(data.get('revision')), image, text(data, 'altText'));
+			await uploadPieceImage(
+				params.id,
+				Number(data.get('revision')),
+				image,
+				text(data, 'altText'),
+				data.get('selectForPresentation') === '1'
+			);
 		} catch (cause) {
 			const code = cause instanceof Error ? cause.message : '';
 			if (code === 'CONFLICT')
@@ -171,5 +262,25 @@ export const actions = {
 			return fail(409, { intent: 'archive', error: saveError(cause).error });
 		}
 		redirect(303, '/archiv');
+	},
+	favorite: async ({ locals, params, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		try {
+			setPieceFavorite(params.id, data.get('favorite') === '1');
+			return { intent: 'favorite', success: true };
+		} catch (cause) {
+			return fail(404, { intent: 'favorite', error: saveError(cause).error });
+		}
+	},
+	delete: async ({ locals, params, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		try {
+			setPieceDeleted(params.id, Number(data.get('revision')), true);
+		} catch (cause) {
+			return fail(409, { intent: 'delete', error: saveError(cause).error });
+		}
+		redirect(303, '/fundus');
 	}
 } satisfies Actions;

src/routes/fundus/[id]/+page.svelte

@@ -2,8 +2,14 @@
 	import { enhance, type SubmitFunction } from '$app/forms';
 	import { beforeNavigate, goto } from '$app/navigation';
 	import { resolve } from '$app/paths';
-	import { onDestroy, untrack } from 'svelte';
+	import { onDestroy, onMount, untrack } from 'svelte';
-	import MarkdownPreview from '#lib/components/MarkdownPreview.svelte';
+	import MarkdownEditorField from '#lib/components/MarkdownEditorField.svelte';
+	import AppIcon from '#lib/components/AppIcon.svelte';
+	import ChoicePicker from '#lib/components/ChoicePicker.svelte';
+	import InlineTitleEditor from '#lib/components/InlineTitleEditor.svelte';
+	import PieceEditorDialog from '#lib/components/PieceEditorDialog.svelte';
+	import PresentationDisplay from '#lib/components/PresentationDisplay.svelte';
+	import type { PresentationContent } from '#lib/server/presentation.js';
 	import type { PageProps } from './$types';
 
 	let { data, form }: PageProps = $props();
@@ -11,10 +17,15 @@
 	let durationMinutes = $state(untrack(() => Number((data.piece.durationSeconds / 60).toFixed(2))));
 	let revision = $state(untrack(() => data.piece.revision));
 	let sources = $state(untrack(() => data.piece.sources.map((source) => ({ ...source }))));
+	let pieceTools = $state(untrack(() => data.piece.tools.map((tool) => ({ ...tool }))));
 	let rendered = $state(untrack(() => ({ ...data.rendered })));
+	let activeSection = $state<'script' | 'research' | 'presentation'>('script');
 	let saveState = $state<'idle' | 'dirty' | 'saving' | 'saved' | 'error' | 'conflict'>('idle');
 	let saveMessage = $state('Alle Änderungen gespeichert');
+	let sourceImageUnavailable = $state(false);
+	let editorDialog: { showModal: () => void; close: () => void };
 	let editorForm: HTMLFormElement;
+	let previewForm: HTMLFormElement;
 	let saveButton: HTMLButtonElement;
 	let timer: ReturnType<typeof setTimeout> | undefined;
 	let generation = 0;
@@ -25,9 +36,66 @@
 			saveState === 'error' ||
 			saveState === 'conflict'
 	);
+	let featuredSource = $derived(
+		draft.presentationSourcePosition === null
+			? (sources[0] ?? null)
+			: (sources[draft.presentationSourcePosition] ?? sources[0] ?? null)
+	);
+	let sourcePreviewImage = $derived(
+		draft.presentationImageUrl
+			? resolve('/fundus/[id]/praesentation/preview-image', { id: data.piece.id })
+			: ''
+	);
+	let selectedMedia = $derived(
+		draft.media.find((media) => media.id === draft.presentationMediaId) ?? null
+	);
+	let previewContent = $derived<
+		PresentationContent & { images: { id: string; altText: string }[] }
+	>({
+		mode: draft.presentationMode,
+		topics: data.taxonomy.topics
+			.filter((topic) => draft.topicIds.includes(topic.id))
+			.map((topic) => topic.name),
+		title: draft.outputTitle || draft.title,
+		html: rendered.presentation,
+		source: featuredSource
+			? {
+					label: featuredSource.label || featuredSource.url,
+					url: featuredSource.url,
+					timecodeSeconds: featuredSource.timecodeSeconds
+				}
+			: null,
+		previewTitle: draft.presentationTitle,
+		description: draft.presentationDescription,
+		imageUrl: draft.presentationImageUrl,
+		siteName: draft.presentationSiteName,
+		provider: draft.presentationProvider as PresentationContent['provider'],
+		providerId: draft.presentationProviderId,
+		embedUrl:
+			draft.presentationProvider === 'youtube' && draft.presentationProviderId
+				? `https://www.youtube-nocookie.com/embed/${draft.presentationProviderId}${featuredSource?.timecodeSeconds ? `?start=${featuredSource.timecodeSeconds}` : ''}`
+				: draft.presentationProvider === 'tiktok' && draft.presentationProviderId
+					? `https://www.tiktok.com/player/v1/${draft.presentationProviderId}`
+					: '',
+		images: selectedMedia ? [{ id: selectedMedia.id, altText: selectedMedia.altText }] : []
+	});
+	let presentationPreviewImage = $derived(
+		selectedMedia
+			? draft.presentationMode === 'text'
+				? '/media'
+				: `/media/${selectedMedia.id}`
+			: sourcePreviewImage
+	);
 	let pendingHref: string | null = null;
 	let allowNavigation = false;
 
+	const statusLabels = {
+		inbox: 'Eingang',
+		preparing: 'In Vorbereitung',
+		ready: 'Sendefertig'
+	};
+
+	onMount(() => editorDialog.showModal());
 	onDestroy(() => clearTimeout(timer));
 	beforeNavigate((navigation) => {
 		if (allowNavigation) return;
@@ -42,7 +110,17 @@
 		if (!saving) submitSave();
 	});
 
-	function scheduleSave() {
+	function scheduleSave(event?: Event) {
+		const control = event?.target;
+		if (event?.type === 'change' && !(control instanceof HTMLSelectElement)) return;
+		if (
+			control instanceof HTMLInputElement &&
+			control.name === 'presentationMode' &&
+			control.value !== 'text' &&
+			draft.presentationSourcePosition === null
+		) {
+			return;
+		}
 		generation += 1;
 		saveState = 'dirty';
 		saveMessage = 'Ungespeicherte Änderungen';
@@ -55,6 +133,23 @@
 		editorForm.requestSubmit(saveButton);
 	}
 
+	function requestClose() {
+		const target = resolve('/fundus');
+		if (saveState === 'error' || saveState === 'conflict') {
+			if (!confirm('Ungespeicherte Änderungen verwerfen und Editor schließen?')) return;
+			allowNavigation = true;
+			void goto(target);
+			return;
+		}
+		if (saveState === 'dirty' || saveState === 'saving') {
+			pendingHref = new URL(target, window.location.href).href;
+			if (!saving) submitSave();
+			return;
+		}
+		allowNavigation = true;
+		void goto(target);
+	}
+
 	function addSource() {
 		sources.push({ label: '', url: '', timecodeSeconds: null });
 		scheduleSave();
@@ -62,9 +157,51 @@
 
 	function removeSource(index: number) {
 		sources.splice(index, 1);
+		if (draft.presentationSourcePosition === index) draft.presentationSourcePosition = null;
+		else if (
+			draft.presentationSourcePosition !== null &&
+			draft.presentationSourcePosition > index
+		) {
+			draft.presentationSourcePosition -= 1;
+		}
 		scheduleSave();
 	}
 
+	function removeTool(index: number) {
+		pieceTools.splice(index, 1);
+		scheduleSave();
+	}
+
+	function selectTools(ids: string[]) {
+		for (const id of ids) {
+			if (pieceTools.some((tool) => tool.toolId === id)) continue;
+			const tool = data.tools.find((item) => item.id === id);
+			if (tool)
+				pieceTools.push({
+					id: crypto.randomUUID(),
+					toolId: tool.id,
+					name: tool.name,
+					startUrl: tool.startUrl,
+					iconName: tool.iconName,
+					isActive: tool.isActive,
+					workUrl: '',
+					note: ''
+				});
+		}
+		pieceTools = pieceTools.filter((tool) => ids.includes(tool.toolId));
+		scheduleSave();
+	}
+
+	function presentationSourceChanged() {
+		draft.presentationMetadataFetchedAtUtc = null;
+		draft.presentationProvider = '';
+		draft.presentationProviderId = '';
+		sourceImageUnavailable = false;
+		if (!draft.presentationTitleManual) draft.presentationTitle = '';
+		if (!draft.presentationDescriptionManual) draft.presentationDescription = '';
+		if (!draft.presentationImageManual) draft.presentationImageUrl = '';
+	}
+
 	const enhanceSave: SubmitFunction = () => {
 		const submittedGeneration = generation;
 		saving = true;
@@ -106,259 +243,549 @@
 
 <svelte:head><title>{draft.title} | Fundus | Sendewerk</title></svelte:head>
 
-<div class="page-wrap editor-page">
+<div class="piece-editor-route">
-	<header class="editor-header">
+	{#if form?.error}<div class="form-message error route-editor-error" role="alert">
-		<div>
+			{form.error}
-			<a class="back-link" href={resolve('/fundus')}>← Fundus</a>
+		</div>{/if}
-			<h1>{draft.title}</h1>
+	<PieceEditorDialog
-		</div>
+		bind:this={editorDialog}
-		<div
+		bind:activeSection
-			class:problem={saveState === 'error' || saveState === 'conflict'}
+		labelledby="piece-editor-title"
-			class="save-indicator"
+		onrequestclose={requestClose}
-			role="status"
-			aria-live="polite"
-		>
-			<i></i><span>{saveMessage}</span>
-		</div>
-	</header>
-	{#if form?.error}<div class="form-message error" role="alert">{form.error}</div>{/if}
-
-	<form
-		bind:this={editorForm}
-		use:enhance={enhanceSave}
-		method="POST"
-		action="?/save"
-		class="piece-editor"
-		oninput={scheduleSave}
-		onchange={scheduleSave}
 	>
-		<input type="hidden" name="revision" value={revision} />
+		{#snippet header()}
-		<section class="editor-section editor-basics">
+			<div class="piece-editor-kicker">
-			<div class="section-title">
+				<p class="eyebrow">Fundusfassung</p>
-				<p class="eyebrow">Grundlagen</p>
+				<form method="POST" action="?/favorite" use:enhance>
-				<h2>Worum geht es?</h2>
+					<input type="hidden" name="favorite" value={data.piece.isFavorite ? '0' : '1'} />
+					<button
+						class="piece-favorite"
+						class:active={data.piece.isFavorite}
+						type="submit"
+						aria-label={data.piece.isFavorite ? 'Aus Favoriten entfernen' : 'Als Favorit markieren'}
+						aria-pressed={data.piece.isFavorite}><AppIcon name="star" /></button
+					>
+				</form>
 			</div>
-			<div class="editor-fields two-columns">
+			<InlineTitleEditor
-				<label class="wide-field"
+				form="piece-editor-form"
-					>Titel<input name="title" required maxlength="200" bind:value={draft.title} /></label
+				bind:value={draft.title}
-				>
+				oncommit={scheduleSave}
-				<label
+			/>
-					>Status<select name="status" bind:value={draft.status}
+			<h1 class="sr-only" id="piece-editor-title">{draft.title}</h1>
-						><option value="inbox">Eingang</option><option value="preparing">In Vorbereitung</option
+		{/snippet}
-						><option value="ready">Sendefertig</option></select
-					></label
-				>
-				<label
-					>Format<select name="formatId" bind:value={draft.formatId}
-						><option value={null}>Ohne Format</option
-						>{#each data.taxonomy.formats as item (item.id)}<option value={item.id}
-								>{item.name}</option
-							>{/each}</select
-					></label
-				>
-				<label
-					>Dauer in Minuten<input
-						name="durationMinutes"
-						type="number"
-						min="0"
-						max="1440"
-						step="any"
-						bind:value={durationMinutes}
-					/></label
-				>
-				<label class="wide-field"
-					>Kurzbeschreibung<textarea
-						name="summary"
-						rows="2"
-						maxlength="2000"
-						bind:value={draft.summary}></textarea></label
-				>
-			</div>
-		</section>
 
-		<section class="editor-section taxonomy-editor">
+		<form
-			<div class="section-title">
+			bind:this={editorForm}
-				<p class="eyebrow">Einordnung</p>
+			id="piece-editor-form"
-				<h2>Themen und Abschnitte</h2>
+			use:enhance={enhanceSave}
-			</div>
+			method="POST"
-			<fieldset>
+			action="?/save"
-				<legend>Themen</legend>
+			class="piece-dialog-form"
-				<div class="choice-grid">
+			oninput={scheduleSave}
-					{#each data.taxonomy.topics as item (item.id)}<label
+			onchange={scheduleSave}
-							><input
+		>
-								type="checkbox"
+			<input type="hidden" name="revision" value={revision} />
-								name="topicIds"
-								value={item.id}
-								bind:group={draft.topicIds}
-							/>{item.name}</label
-						>{/each}
-				</div>
-			</fieldset>
-			<fieldset>
-				<legend>Vorgeschlagene Abschnittskategorien</legend>
-				<div class="choice-grid">
-					{#each data.taxonomy.categories as item (item.id)}<label
-							><input
-								type="checkbox"
-								name="categoryIds"
-								value={item.id}
-								bind:group={draft.categoryIds}
-							/><i style={`--choice-color:${item.color}`}></i>{item.name}</label
-						>{/each}
-				</div>
-			</fieldset>
-		</section>
 
-		<section class="editor-section markdown-section">
+			<section class="piece-editor-panel" hidden={activeSection !== 'script'}>
-			<div class="section-title">
+				<div class="piece-panel-heading">
-				<p class="eyebrow">Redaktion</p>
+					<div>
-				<h2>Getrennte Arbeitsbereiche</h2>
+						<p class="eyebrow">Für die Moderation</p>
-				<small>Markdown wird unterstützt und vor der Anzeige bereinigt.</small>
+						<h2>Sendungstext</h2>
-			</div>
+					</div>
-			<div class="markdown-grid">
+				</div>
-				<label
+				<div class="piece-writing-stack">
-					><span>Einleitung</span><textarea
+					<MarkdownEditorField
 						name="intro"
-						rows="7"
+						label="Einleitung"
-						maxlength="50000"
+						placeholder="Wie beginnt dieses Thema in der Sendung?"
-						bind:value={draft.intro}></textarea>
+						bind:value={draft.intro}
-					<MarkdownPreview html={rendered.intro} /></label
+					/>
-				>
+					<MarkdownEditorField
-				<label class="private-field"
-					><span>Private Recherche</span><textarea
-						name="researchText"
-						rows="7"
-						maxlength="50000"
-						bind:value={draft.researchText}></textarea>
-					<MarkdownPreview html={rendered.research} /></label
-				>
-				<label
-					><span>Moderationsstichpunkte</span><textarea
 						name="moderationNotes"
-						rows="7"
+						label="Moderationsstichpunkte"
-						maxlength="50000"
+						placeholder="Argumente, Fragen und Ablaufpunkte"
-						bind:value={draft.moderationNotes}></textarea>
+						rows={10}
-					<MarkdownPreview html={rendered.moderation} /></label
+						bind:value={draft.moderationNotes}
-				>
+					/>
-				<label
+					<MarkdownEditorField
-					><span>Überleitung</span><textarea
 						name="transitionText"
-						rows="7"
+						label="Überleitung"
-						maxlength="50000"
+						placeholder="Wie geht es zum nächsten Thema weiter?"
-						bind:value={draft.transitionText}></textarea>
+						bind:value={draft.transitionText}
-					<MarkdownPreview html={rendered.transition} /></label
+					/>
-				>
-				<label class="wide-field"
-					><span>Präsentationstext</span><textarea
-						name="presentationText"
-						rows="7"
-						maxlength="50000"
-						bind:value={draft.presentationText}></textarea>
-					<MarkdownPreview html={rendered.presentation} /></label
-				>
-			</div>
-		</section>
-
-		<section class="editor-section source-editor">
-			<div class="section-title split-section-title">
-				<div>
-					<p class="eyebrow">Belege</p>
-					<h2>Quellen</h2>
 				</div>
-				<button class="secondary-button" type="button" onclick={addSource}>Quelle hinzufügen</button
+				<details class="piece-meta-details">
-				>
+					<summary>
-			</div>
+						<span>Status, Dauer und Einordnung</span>
-			{#if sources.length}<div class="source-list">
+						<small
-					{#each sources as source, index (index)}<div class="source-row">
+							>{statusLabels[draft.status as keyof typeof statusLabels]} · {durationMinutes || 0} Min.</small
+						>
+					</summary>
+					<div class="piece-meta-grid">
+						<label
+							>Status<select name="status" bind:value={draft.status}
+								><option value="inbox">Eingang</option><option value="preparing"
+									>In Vorbereitung</option
+								><option value="ready">Sendefertig</option></select
+							></label
+						>
+						<label
+							>Dauer in Minuten<input
+								name="durationMinutes"
+								type="number"
+								min="0"
+								max="1440"
+								step="any"
+								bind:value={durationMinutes}
+							/></label
+						>
+						<label
+							>Format<select name="formatId" bind:value={draft.formatId}
+								><option value={null}>Ohne Format</option
+								>{#each data.taxonomy.formats as item (item.id)}<option value={item.id}
+										>{item.name}</option
+									>{/each}</select
+							></label
+						>
+						<label class="wide-field"
+							>Kurzbeschreibung<textarea
+								name="summary"
+								rows="3"
+								maxlength="2000"
+								placeholder="Worum geht es in wenigen Sätzen?"
+								bind:value={draft.summary}></textarea></label
+						>
+						<fieldset>
+							<legend>Themen</legend><ChoicePicker
+								items={data.taxonomy.topics}
+								selectedIds={draft.topicIds}
+								label="Themen"
+								fieldName="topicIds"
+								onselectionchange={(ids) => {
+									draft.topicIds = ids;
+									scheduleSave();
+								}}
+							/>
+						</fieldset>
+						<fieldset>
+							<legend>Vorgeschlagene Abschnittskategorien</legend>
+							<div class="choice-grid">
+								{#each data.taxonomy.categories as item (item.id)}<label
+										><input
+											type="checkbox"
+											name="categoryIds"
+											value={item.id}
+											bind:group={draft.categoryIds}
+										/><i style={`--choice-color:${item.color}`}></i>{item.name}</label
+									>{/each}
+							</div>
+						</fieldset>
+					</div>
+				</details>
+			</section>
+
+			<section class="piece-editor-panel" hidden={activeSection !== 'research'}>
+				<div class="piece-panel-heading">
+					<div>
+						<p class="eyebrow">Nicht öffentlich</p>
+						<h2>Recherche & Quellen</h2>
+					</div>
+					<small>Recherche und Material bleiben innerhalb der Redaktion.</small>
+				</div>
+				<MarkdownEditorField
+					name="researchText"
+					label="Private Recherche"
+					placeholder="Hintergrund, Prüfung und offene Fragen"
+					rows={10}
+					privateField
+					bind:value={draft.researchText}
+				/>
+				<section class="piece-source-editor">
+					<div class="piece-subsection-heading">
+						<div>
+							<p class="eyebrow">Fundstellen</p>
+							<h3>Quellen</h3>
+						</div>
+						<button class="secondary-button" type="button" onclick={addSource}
+							>Quelle hinzufügen</button
+						>
+					</div>
+					{#if sources.length}<div class="source-list">
+							{#each sources as source, index (index)}<div class="source-row">
+									<label
+										>Name<input
+											name="sourceLabel"
+											maxlength="200"
+											placeholder="Name der Quelle"
+											bind:value={source.label}
+										/></label
+									><label
+										>URL<input
+											name="sourceUrl"
+											type="url"
+											maxlength="2000"
+											placeholder="https://…"
+											bind:value={source.url}
+										/></label
+									><label
+										>Zeitmarke in Sekunden<input
+											name="sourceTimecode"
+											type="number"
+											min="0"
+											max="86400"
+											placeholder="Optional"
+											bind:value={source.timecodeSeconds}
+										/></label
+									><button
+										class="text-button danger-text"
+										type="button"
+										onclick={() => removeSource(index)}>Entfernen</button
+									>
+								</div>{/each}
+						</div>{:else}<p class="context-empty">Noch keine Quelle hinterlegt.</p>{/if}
+				</section>
+				<section class="piece-source-editor">
+					<div class="piece-subsection-heading">
+						<div>
+							<p class="eyebrow">Arbeitsmittel</p>
+							<h3>Werkzeuge</h3>
+						</div>
+						<ChoicePicker
+							items={data.tools
+								.filter((tool) => tool.isActive)
+								.map((tool) => ({
+									id: tool.id,
+									name: tool.name,
+									description: tool.description,
+									iconName: tool.iconName,
+									meta: tool.formatIds.includes(draft.formatId ?? '') ? 'Passt zum Format' : ''
+								}))}
+							selectedIds={pieceTools.map((tool) => tool.toolId)}
+							label="Werkzeuge"
+							onselectionchange={selectTools}
+						/>
+					</div>
+					{#if pieceTools.length}<div class="source-list">
+							{#each pieceTools as tool, index (tool.id)}<div
+									class="source-row tool-assignment-row"
+								>
+									<input type="hidden" name="toolId" value={tool.toolId} />
+									<div class="tool-assignment-name">
+										<AppIcon name={tool.iconName || 'wrench'} /><span
+											><strong>{tool.name}</strong>{#if !tool.isActive}<small>Deaktiviert</small
+												>{/if}</span
+										>
+									</div>
+									<label
+										>Arbeitslink<input
+											name="toolWorkUrl"
+											type="url"
+											maxlength="2000"
+											placeholder={tool.startUrl || 'https://…'}
+											bind:value={tool.workUrl}
+										/></label
+									>
+									<label
+										>Notiz<input
+											name="toolNote"
+											maxlength="2000"
+											placeholder="Optional"
+											bind:value={tool.note}
+										/></label
+									>
+									<button
+										class="text-button danger-text"
+										type="button"
+										onclick={() => removeTool(index)}>Entfernen</button
+									>
+								</div>{/each}
+						</div>{:else}<p class="context-empty">Noch kein Werkzeug zugeordnet.</p>{/if}
+				</section>
+			</section>
+
+			<section class="piece-editor-panel" hidden={activeSection !== 'presentation'}>
+				<div class="piece-panel-heading">
+					<div>
+						<p class="eyebrow">Öffentliche Ausgabe</p>
+						<h2>Präsentation</h2>
+					</div>
+					<a
+						class="secondary-button"
+						href={resolve('/fundus/[id]/praesentation', { id: data.piece.id })}
+						target="_blank"
+						rel="noopener">In neuem Fenster testen</a
+					>
+				</div>
+				<div class="piece-presentation-layout">
+					<div class="piece-presentation-controls">
+						<label
+							>Präsentationstitel<input
+								name="outputTitle"
+								maxlength="300"
+								placeholder="Optional, sonst interner Titel"
+								bind:value={draft.outputTitle}
+							/></label
+						>
+						<MarkdownEditorField
+							name="presentationText"
+							label="Öffentlicher Text"
+							placeholder="Text für die Publikumsausgabe"
+							rows={8}
+							bind:value={draft.presentationText}
+						/>
+						<div class="presentation-mode-picker" role="group" aria-label="Darstellung">
+							{#each [['text', 'Text'], ['link', 'Linkvorschau'], ['video', 'Video']] as mode (mode[0])}<label
+									><input
+										type="radio"
+										name="presentationMode"
+										value={mode[0]}
+										bind:group={draft.presentationMode}
+									/>{mode[1]}</label
+								>{/each}
+						</div>
+						<div class="presentation-settings">
 							<label
-								>Name<input name="sourceLabel" maxlength="200" bind:value={source.label} /></label
+								>Quelle<select
-							><label
+									name="presentationSourcePosition"
-								>URL<input
+									bind:value={draft.presentationSourcePosition}
-									name="sourceUrl"
+									onchange={presentationSourceChanged}
+									><option value={null}>Quelle auswählen</option
+									>{#each sources as source, index (index)}{#if source.url}<option value={index}
+												>{source.label || source.url}</option
+											>{/if}{/each}</select
+								></label
+							>
+							<label
+								>Kartentitel<input
+									name="presentationTitle"
+									maxlength="300"
+									placeholder="Optionaler Anzeigetitel"
+									bind:value={draft.presentationTitle}
+									oninput={() => (draft.presentationTitleManual = true)}
+								/></label
+							>
+							<label
+								>Bild-URL<input
+									name="presentationImageUrl"
 									type="url"
 									maxlength="2000"
-									bind:value={source.url}
+									placeholder="https://…"
+									bind:value={draft.presentationImageUrl}
+									oninput={() => (draft.presentationImageManual = true)}
 								/></label
-							><label
-								>Zeitmarke in Sekunden<input
-									name="sourceTimecode"
-									type="number"
-									min="0"
-									max="86400"
-									bind:value={source.timecodeSeconds}
-								/></label
-							><button
-								class="text-button danger-text"
-								type="button"
-								onclick={() => removeSource(index)}>Entfernen</button
 							>
-						</div>{/each}
+							<label class="wide-field"
-				</div>{:else}<p class="quiet-copy">Noch keine Quellen hinterlegt.</p>{/if}
+								>Anreißer<textarea
+									name="presentationDescription"
+									rows="3"
+									maxlength="1000"
+									placeholder="Kurzer Text zur Vorschau"
+									bind:value={draft.presentationDescription}
+									oninput={() => (draft.presentationDescriptionManual = true)}></textarea></label
+							>
+							<div class="presentation-preview-actions wide-field">
+								<button
+									class="secondary-button"
+									type="button"
+									onclick={() => previewForm.requestSubmit()}
+									disabled={actionsBlocked || draft.presentationSourcePosition === null}
+									>Vorschau laden</button
+								><small
+									>{draft.presentationMetadataFetchedAtUtc
+										? `Zuletzt geladen: ${new Date(draft.presentationMetadataFetchedAtUtc).toLocaleString('de-DE')}`
+										: 'Noch keine Metadaten geladen.'}</small
+								>
+							</div>
+						</div>
+					</div>
+					<aside class="piece-presentation-preview" aria-label="Präsentationsvorschau">
+						<PresentationDisplay
+							content={previewContent}
+							imageSrc={sourceImageUnavailable ? '' : presentationPreviewImage}
+						/>
+					</aside>
+				</div>
+				<input
+					type="hidden"
+					name="presentationTitleManual"
+					value={draft.presentationTitleManual ? '1' : '0'}
+				/>
+				<input
+					type="hidden"
+					name="presentationDescriptionManual"
+					value={draft.presentationDescriptionManual ? '1' : '0'}
+				/>
+				<input
+					type="hidden"
+					name="presentationImageManual"
+					value={draft.presentationImageManual ? '1' : '0'}
+				/>
+				<input type="hidden" name="presentationSiteName" value={draft.presentationSiteName} />
+				<input type="hidden" name="presentationProvider" value={draft.presentationProvider} />
+				<input type="hidden" name="presentationProviderId" value={draft.presentationProviderId} />
+				<input
+					type="hidden"
+					name="presentationMetadataFetchedAtUtc"
+					value={draft.presentationMetadataFetchedAtUtc ?? ''}
+				/>
+			</section>
+		</form>
+
+		<section class="piece-editor-panel piece-media-panel" hidden={activeSection !== 'presentation'}>
+			<div class="piece-subsection-heading">
+				<div>
+					<p class="eyebrow">Hochgeladene Bilder</p>
+					<h3>Präsentationsbild</h3>
+				</div>
+				<small>JPEG, PNG, WebP oder GIF bis 5 MB</small>
+			</div>
+			{#if data.piece.media.length}<label class="media-none"
+					><input
+						form="piece-editor-form"
+						type="radio"
+						name="presentationMediaId"
+						value=""
+						checked={!draft.presentationMediaId}
+						onchange={() => {
+							draft.presentationMediaId = null;
+							scheduleSave();
+						}}
+					/> Kein hochgeladenes Bild</label
+				>
+				<div class="media-grid">
+					{#each data.piece.media as media (media.id)}<figure>
+							<label class="media-presentation-choice"
+								><input
+									form="piece-editor-form"
+									type="radio"
+									name="presentationMediaId"
+									value={media.id}
+									checked={draft.presentationMediaId === media.id}
+									onchange={() => {
+										draft.presentationMediaId = media.id;
+										scheduleSave();
+									}}
+								/><img src={`/media/${media.id}`} alt={media.altText} /><span
+									>Als Präsentationsbild</span
+								></label
+							>
+							<figcaption>
+								<span>{media.altText || media.originalName}</span>
+								<form method="POST" action="?/deleteImage">
+									<input type="hidden" name="revision" value={revision} /><input
+										type="hidden"
+										name="mediaId"
+										value={media.id}
+									/><button class="text-button danger-text" type="submit" disabled={actionsBlocked}
+										>Entfernen</button
+									>
+								</form>
+							</figcaption>
+						</figure>{/each}
+				</div>{/if}
+			<form method="POST" action="?/upload" enctype="multipart/form-data" class="upload-form">
+				<input type="hidden" name="revision" value={revision} /><label
+					>Bild<input
+						name="image"
+						type="file"
+						accept="image/jpeg,image/png,image/webp,image/gif"
+						required
+					/></label
+				><label
+					>Alternativtext<input
+						name="altText"
+						maxlength="300"
+						placeholder="Was ist auf dem Bild zu sehen?"
+					/></label
+				><button class="secondary-button" type="submit" disabled={actionsBlocked}
+					>Bild hochladen</button
+				>
+				<label class="upload-select"
+					><input type="checkbox" name="selectForPresentation" value="1" checked /> Direkt als Präsentationsbild
+					verwenden</label
+				>
+			</form>
 		</section>
 
-		<div class="editor-savebar">
+		{#snippet footer()}
-			<span class:problem={saveState === 'error' || saveState === 'conflict'}>{saveMessage}</span
+			<div class="piece-dialog-secondary-actions">
-			><button bind:this={saveButton} class="primary-button" type="submit" disabled={saving}
+				<details class="template-save-menu">
-				>Jetzt speichern</button
+					<summary>Als Vorlage speichern</summary>
-			>
+					<form method="POST" action="?/saveTemplate">
-		</div>
+						<label
+							>Vorlage<select name="templateRef">
+								<option value="">Neue Vorlage</option>
+								{#each data.templates as template (template.id)}<option
+										value={`${template.id}|${template.revision}`}>{template.name}</option
+									>{/each}
+							</select></label
+						>
+						<label>Name<input name="templateName" required maxlength="120" /></label>
+						<label>Beschreibung<input name="templateDescription" maxlength="500" /></label>
+						<button class="text-button" type="submit" disabled={actionsBlocked}
+							>Vorlage speichern</button
+						>
+					</form>
+				</details>
+				<form method="POST" action="?/duplicate">
+					<button class="text-button" type="submit" disabled={actionsBlocked}>Duplizieren</button>
+				</form>
+				<form method="POST" action="?/archive">
+					<input type="hidden" name="revision" value={revision} /><button
+						class="text-button danger-text"
+						type="submit"
+						aria-label="Piece archivieren"
+						disabled={actionsBlocked}>Archivieren</button
+					>
+				</form>
+				<form
+					method="POST"
+					action="?/delete"
+					onsubmit={(event) =>
+						!confirm('Piece löschen? Bestehende Sendungsfassungen bleiben erhalten.') &&
+						event.preventDefault()}
+				>
+					<input type="hidden" name="revision" value={revision} /><button
+						class="text-button danger-text"
+						type="submit"
+						disabled={actionsBlocked}>Piece löschen</button
+					>
+				</form>
+			</div>
+			<div class="piece-dialog-primary-action">
+				<span
+					class="save-indicator"
+					class:problem={saveState === 'error' || saveState === 'conflict'}
+					role="status"
+					aria-live="polite">{saveMessage}</span
+				>
+				<button
+					bind:this={saveButton}
+					class:primary-button={saveState === 'dirty' ||
+						saveState === 'error' ||
+						saveState === 'conflict'}
+					class:secondary-button={saveState === 'idle' ||
+						saveState === 'saved' ||
+						saveState === 'saving'}
+					type="submit"
+					form="piece-editor-form"
+					disabled={saving}
+					>{saveState === 'error' || saveState === 'conflict'
+						? 'Erneut speichern'
+						: 'Speichern'}</button
+				>
+			</div>
+		{/snippet}
+	</PieceEditorDialog>
+
+	<form
+		bind:this={previewForm}
+		id="preview-load-form"
+		method="POST"
+		action="?/loadPreview"
+		use:enhance
+	>
+		<input type="hidden" name="revision" value={revision} />
 	</form>
-
-	<section class="editor-section media-editor">
-		<div class="section-title">
-			<p class="eyebrow">Private Dateien</p>
-			<h2>Bilder</h2>
-			<small>JPEG, PNG, WebP oder GIF bis 5 MB; nur angemeldet abrufbar.</small>
-		</div>
-		{#if data.piece.media.length}<div class="media-grid">
-				{#each data.piece.media as media (media.id)}<figure>
-						<img src={`/media/${media.id}`} alt={media.altText} />
-						<figcaption>
-							<span>{media.altText || media.originalName}</span>
-							<form method="POST" action="?/deleteImage">
-								<input type="hidden" name="revision" value={revision} /><input
-									type="hidden"
-									name="mediaId"
-									value={media.id}
-								/><button class="text-button danger-text" type="submit" disabled={actionsBlocked}
-									>Entfernen</button
-								>
-							</form>
-						</figcaption>
-					</figure>{/each}
-			</div>{/if}
-		<form method="POST" action="?/upload" enctype="multipart/form-data" class="upload-form">
-			<input type="hidden" name="revision" value={revision} /><label
-				>Bild<input
-					name="image"
-					type="file"
-					accept="image/jpeg,image/png,image/webp,image/gif"
-					required
-				/></label
-			><label
-				>Alternativtext<input
-					name="altText"
-					maxlength="300"
-					placeholder="Was ist auf dem Bild zu sehen?"
-				/></label
-			><button class="secondary-button" type="submit" disabled={actionsBlocked}
-				>Bild hochladen</button
-			>
-		</form>
-	</section>
-
-	<section class="editor-actions">
-		<form method="POST" action="?/duplicate">
-			<button class="secondary-button" type="submit" disabled={actionsBlocked}
-				>Piece duplizieren</button
-			>
-		</form>
-		<form method="POST" action="?/archive">
-			<input type="hidden" name="revision" value={revision} /><button
-				class="secondary-button danger-text"
-				type="submit"
-				disabled={actionsBlocked}>Piece archivieren</button
-			>
-		</form>
-	</section>
 </div>

src/routes/fundus/[id]/praesentation/+page.server.ts

@@ -0,0 +1,49 @@
+import { error } from '@sveltejs/kit';
+import type { PageServerLoad } from './$types';
+import { requireUser } from '#lib/server/auth.js';
+import { getPiece, getTaxonomy } from '#lib/server/content.js';
+import { renderMarkdown } from '#lib/server/markdown.js';
+import { buildEmbedUrl, type PresentationContent } from '#lib/server/presentation.js';
+
+export const load: PageServerLoad = ({ locals, params }) => {
+	requireUser(locals.user);
+	const piece = getPiece(params.id);
+	if (!piece) error(404, 'Piece nicht gefunden');
+	const source =
+		piece.presentationSourcePosition === null
+			? null
+			: (piece.sources[piece.presentationSourcePosition] ?? null);
+	const content: PresentationContent & {
+		sources: typeof piece.sources;
+		images: { id: string; altText: string }[];
+	} = {
+		mode: piece.presentationMode,
+		topics: getTaxonomy()
+			.topics.filter((topic) => piece.topicIds.includes(topic.id))
+			.map((topic) => topic.name),
+		title: piece.outputTitle || piece.title,
+		html: renderMarkdown(piece.presentationText),
+		source,
+		previewTitle: piece.presentationTitle,
+		description: piece.presentationDescription,
+		imageUrl: piece.presentationImageUrl,
+		siteName: piece.presentationSiteName,
+		provider:
+			piece.presentationProvider === 'youtube' || piece.presentationProvider === 'tiktok'
+				? piece.presentationProvider
+				: '',
+		providerId: piece.presentationProviderId,
+		embedUrl: buildEmbedUrl(
+			piece.presentationProvider === 'youtube' || piece.presentationProvider === 'tiktok'
+				? piece.presentationProvider
+				: '',
+			piece.presentationProviderId,
+			source?.timecodeSeconds ?? null
+		),
+		sources: [],
+		images: piece.media
+			.filter((item) => item.id === piece.presentationMediaId)
+			.map((item) => ({ id: item.id, altText: item.altText }))
+	};
+	return { pieceId: piece.id, content };
+};

src/routes/fundus/[id]/praesentation/+page.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">
+	import PresentationDisplay from '#lib/components/PresentationDisplay.svelte';
+	import type { PageProps } from './$types';
+
+	let { data }: PageProps = $props();
+</script>
+
+<svelte:head>
+	<title>Präsentation testen | Sendewerk</title>
+	<meta name="robots" content="noindex, nofollow, noarchive" />
+</svelte:head>
+
+<main class="heinzlive-output presentation-test-output">
+	<div class="presentation-test-status" role="status">Isolierte Testansicht</div>
+	<PresentationDisplay
+		content={data.content}
+		imageSrc={data.content.images.length
+			? data.content.mode === 'text'
+				? '/media'
+				: `/media/${data.content.images[0].id}`
+			: `/fundus/${data.pieceId}/praesentation/preview-image`}
+	/>
+</main>

src/routes/fundus/[id]/praesentation/preview-image/+server.ts

@@ -0,0 +1,26 @@
+import { error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { requireUser } from '#lib/server/auth.js';
+import { getPiece } from '#lib/server/content.js';
+import { fetchPresentationImage } from '#lib/server/presentation.js';
+
+export const GET: RequestHandler = async ({ locals, params }) => {
+	requireUser(locals.user);
+	const piece = getPiece(params.id);
+	if (!piece?.presentationImageUrl) error(404, 'Vorschaubild nicht verfügbar');
+	try {
+		const image = await fetchPresentationImage(piece.presentationImageUrl);
+		return new Response(new Uint8Array(image.data), {
+			headers: {
+				'Content-Type': image.mimeType,
+				'Content-Length': String(image.data.byteLength),
+				'Cache-Control': 'private, max-age=300',
+				'X-Content-Type-Options': 'nosniff',
+				'Cross-Origin-Resource-Policy': 'same-origin',
+				'Content-Security-Policy': "default-src 'none'; sandbox"
+			}
+		});
+	} catch {
+		error(404, 'Vorschaubild nicht verfügbar');
+	}
+};

src/routes/heinzlive/[token]/+page.server.ts

@@ -0,0 +1,10 @@
+import type { PageServerLoad } from './$types';
+import { getPresentationChannelView, presentationChannelAccess } from '#lib/server/live.js';
+
+export const load: PageServerLoad = ({ params, cookies }) => {
+	const accessKey = cookies.get(`sendewerk-output-${params.token}`) ?? '';
+	const view = presentationChannelAccess(params.token, accessKey)
+		? getPresentationChannelView(params.token)
+		: null;
+	return { view, channelId: params.token };
+};

src/routes/heinzlive/[token]/+page.svelte

@@ -0,0 +1,75 @@
+<script lang="ts">
+	import { page } from '$app/state';
+	import { onMount, untrack } from 'svelte';
+	import PresentationDisplay from '#lib/components/PresentationDisplay.svelte';
+	import type { PageProps } from './$types';
+
+	let { data }: PageProps = $props();
+	let view = $state(untrack(() => data.view ?? { revision: -1, content: null }));
+	let connection = $state<'connected' | 'waiting' | 'interrupted'>(
+		untrack(() => (data.view ? 'connected' : 'waiting'))
+	);
+
+	onMount(() => {
+		let stopped = false;
+		let timer: ReturnType<typeof setTimeout>;
+		async function refresh() {
+			try {
+				const response = await fetch(`/heinzlive/${page.params.token}/state`, {
+					headers: { Accept: 'application/json' },
+					cache: 'no-store'
+				});
+				if (!response.ok) throw new Error('STATE_UNAVAILABLE');
+				const next = await response.json();
+				if (next.revision !== view.revision) view = next;
+				connection = 'connected';
+			} catch {
+				connection = 'interrupted';
+			}
+			if (!stopped) timer = setTimeout(refresh, connection === 'interrupted' ? 3000 : 1000);
+		}
+		async function connect() {
+			const accessKey = decodeURIComponent(location.hash.slice(1));
+			if (accessKey) {
+				const response = await fetch(`/heinzlive/${data.channelId}/access`, {
+					method: 'POST',
+					headers: { 'Content-Type': 'application/json' },
+					body: JSON.stringify({ key: accessKey })
+				});
+				if (!response.ok) {
+					connection = 'interrupted';
+					return;
+				}
+			}
+			timer = setTimeout(refresh, 0);
+		}
+		void connect();
+		return () => {
+			stopped = true;
+			clearTimeout(timer);
+		};
+	});
+</script>
+
+<svelte:head>
+	<title>heinzlive</title>
+	<meta name="robots" content="noindex, nofollow, noarchive" />
+</svelte:head>
+
+<main class:empty={!view.content} class="heinzlive-output">
+	<div class="output-connection sr-only" class:problem={connection === 'interrupted'} role="status">
+		<span></span>{connection === 'interrupted' ? 'Verbindung unterbrochen' : 'Verbunden'}
+	</div>
+	{#if view.content}
+		{#key view.revision}
+			<PresentationDisplay
+				content={view.content}
+				imageSrc={view.content.images.length
+					? view.content.mode === 'text'
+						? `/heinzlive/${page.params.token}/media`
+						: `/heinzlive/${page.params.token}/media/${view.content.images[0].id}`
+					: `/heinzlive/${page.params.token}/preview-image`}
+			/>
+		{/key}
+	{/if}
+</main>

src/routes/heinzlive/[token]/access/+server.ts

@@ -0,0 +1,18 @@
+import { error, json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { presentationChannelAccess } from '#lib/server/live.js';
+
+export const POST: RequestHandler = async ({ params, request, cookies, url }) => {
+	const body = (await request.json().catch(() => null)) as { key?: unknown } | null;
+	const accessKey = typeof body?.key === 'string' ? body.key : '';
+	if (!presentationChannelAccess(params.token, accessKey)) {
+		error(404, 'Präsentationsausgabe nicht gefunden');
+	}
+	cookies.set(`sendewerk-output-${params.token}`, accessKey, {
+		path: `/heinzlive/${params.token}`,
+		httpOnly: true,
+		sameSite: 'strict',
+		secure: url.protocol === 'https:'
+	});
+	return json({ success: true }, { headers: { 'Cache-Control': 'no-store' } });
+};

src/routes/heinzlive/[token]/media/[id]/+server.ts

@@ -0,0 +1,20 @@
+import { error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { getPresentationMedia, presentationChannelAccess } from '#lib/server/live.js';
+
+export const GET: RequestHandler = async ({ params, cookies }) => {
+	const accessKey = cookies.get(`sendewerk-output-${params.token}`) ?? '';
+	if (!presentationChannelAccess(params.token, accessKey)) error(404, 'Bild nicht gefunden');
+	const media = await getPresentationMedia(accessKey, params.id);
+	if (!media) error(404, 'Bild nicht gefunden');
+	return new Response(new Uint8Array(media.data), {
+		headers: {
+			'Content-Type': media.mimeType,
+			'Content-Length': String(media.byteSize),
+			'Cache-Control': 'no-store',
+			'Content-Security-Policy': "default-src 'none'; sandbox",
+			'Cross-Origin-Resource-Policy': 'same-origin',
+			'X-Content-Type-Options': 'nosniff'
+		}
+	});
+};

src/routes/heinzlive/[token]/preview-image/+server.ts

@@ -0,0 +1,21 @@
+import { error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { getPresentationPreviewImage, presentationChannelAccess } from '#lib/server/live.js';
+
+export const GET: RequestHandler = async ({ params, cookies }) => {
+	const accessKey = cookies.get(`sendewerk-output-${params.token}`) ?? '';
+	if (!presentationChannelAccess(params.token, accessKey))
+		error(404, 'Vorschaubild nicht verfügbar');
+	const image = await getPresentationPreviewImage(accessKey);
+	if (!image) error(404, 'Vorschaubild nicht verfügbar');
+	return new Response(new Uint8Array(image.data), {
+		headers: {
+			'Content-Type': image.mimeType,
+			'Content-Length': String(image.data.byteLength),
+			'Cache-Control': 'private, max-age=300',
+			'X-Content-Type-Options': 'nosniff',
+			'Cross-Origin-Resource-Policy': 'same-origin',
+			'Content-Security-Policy': "default-src 'none'; sandbox"
+		}
+	});
+};

src/routes/heinzlive/[token]/state/+server.ts

@@ -0,0 +1,12 @@
+import { error, json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { getPresentationChannelView, presentationChannelAccess } from '#lib/server/live.js';
+
+export const GET: RequestHandler = ({ params, cookies }) => {
+	const accessKey = cookies.get(`sendewerk-output-${params.token}`) ?? '';
+	if (!presentationChannelAccess(params.token, accessKey))
+		error(404, 'Präsentationsausgabe nicht gefunden');
+	const view = getPresentationChannelView(params.token);
+	if (!view) error(404, 'Präsentationsausgabe nicht gefunden');
+	return json(view, { headers: { 'Cache-Control': 'no-store' } });
+};

src/routes/live/+page.server.ts

@@ -1,15 +1,159 @@
-import { getShow } from '#lib/server/previews.js';
+import { randomUUID } from 'node:crypto';
+import { error, fail } from '@sveltejs/kit';
+import type { Actions, PageServerLoad } from './$types';
+import { requireUser } from '#lib/server/auth.js';
+import {
+	completeCurrent,
+	clearPresentationChannel,
+	getLiveView,
+	goBack,
+	issuePresentationAccess,
+	moveOpenUsage,
+	presentUsage,
+	rotatePresentationChannelKey,
+	selectUsage,
+	skipCurrent,
+	startOrResumeLive
+} from '#lib/server/live.js';
+import { listShows } from '#lib/server/shows.js';
 
-export function load({ url }) {
+function text(data: FormData, name: string) {
-	const show = getShow(url.searchParams.get('show') || undefined);
+	return String(data.get(name) || '');
-	const usages = show.sections.flatMap((section) =>
-		section.usages
-			.filter((usage) => !usage.isReserve)
-			.map((usage) => ({ ...usage, section: section.name }))
-	);
-	const currentIndex = Math.max(
-		0,
-		usages.findIndex((usage) => usage.status === 'current')
-	);
-	return { show, current: usages[currentIndex] ?? null, next: usages[currentIndex + 1] ?? null };
 }
+
+function actionError(cause: unknown) {
+	const code = cause instanceof Error ? cause.message : '';
+	if (code === 'CONFLICT')
+		return {
+			status: 409,
+			error: 'Der Live-Stand wurde bereits geändert. Die Ansicht wurde erneuert.'
+		};
+	if (code === 'NO_CURRENT') return { status: 409, error: 'Es ist kein aktuelles Piece aktiv.' };
+	if (code === 'NOT_STARTED')
+		return { status: 409, error: 'Die Sendung muss vor der Auswahl gestartet werden.' };
+	if (code === 'NO_PREVIOUS') return { status: 409, error: 'Es gibt kein vorheriges Piece.' };
+	if (code === 'LIVE_ORDER_LOCKED')
+		return {
+			status: 409,
+			error: 'Nur offene Pieces hinter dem aktuellen Stand können sortiert werden.'
+		};
+	if (code === 'SHOW_COMPLETED')
+		return { status: 409, error: 'Abgeschlossene Sendungen können nicht live gesteuert werden.' };
+	if (code === 'NOT_FOUND')
+		return { status: 404, error: 'Sendung oder Piece wurde nicht gefunden.' };
+	if (code.startsWith('INVALID_')) return { status: 400, error: 'Die Live-Aktion ist ungültig.' };
+	return { status: 500, error: 'Die Live-Aktion konnte nicht gespeichert werden.' };
+}
+
+function attempt(intent: string, operation: () => unknown) {
+	try {
+		return { intent, success: true, result: operation() };
+	} catch (cause) {
+		const problem = actionError(cause);
+		return fail(problem.status, { intent, ...problem });
+	}
+}
+
+export const load: PageServerLoad = ({ locals, url }) => {
+	requireUser(locals.user);
+	const showId = url.searchParams.get('show') || listShows()[0]?.id;
+	if (!showId) error(404, 'Keine Sendung vorhanden');
+	try {
+		return { live: getLiveView(showId), commandId: randomUUID() };
+	} catch (cause) {
+		if (cause instanceof Error && cause.message === 'NOT_FOUND')
+			error(404, 'Sendung nicht gefunden');
+		throw cause;
+	}
+};
+
+export const actions = {
+	start: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		return attempt('start', () =>
+			startOrResumeLive(text(data, 'showId'), text(data, 'commandId'), Number(data.get('revision')))
+		);
+	},
+	complete: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		return attempt('complete', () =>
+			completeCurrent(text(data, 'showId'), text(data, 'commandId'), Number(data.get('revision')))
+		);
+	},
+	skip: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		return attempt('skip', () =>
+			skipCurrent(text(data, 'showId'), text(data, 'commandId'), Number(data.get('revision')))
+		);
+	},
+	back: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		return attempt('back', () =>
+			goBack(text(data, 'showId'), text(data, 'commandId'), Number(data.get('revision')))
+		);
+	},
+	select: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		return attempt('select', () =>
+			selectUsage(
+				text(data, 'showId'),
+				text(data, 'usageId'),
+				text(data, 'commandId'),
+				Number(data.get('revision'))
+			)
+		);
+	},
+	present: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		return attempt('present', () =>
+			presentUsage(
+				text(data, 'showId'),
+				text(data, 'usageId') || null,
+				text(data, 'commandId'),
+				Number(data.get('revision'))
+			)
+		);
+	},
+	moveUsage: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		return attempt('moveUsage', () =>
+			moveOpenUsage(text(data, 'showId'), text(data, 'usageId'), Number(data.get('showRevision')), {
+				sectionId: text(data, 'sectionId') || null,
+				position: Number(data.get('position'))
+			})
+		);
+	},
+	createOutput: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		try {
+			const token = issuePresentationAccess(text(data, 'showId'));
+			return { intent: 'createOutput', success: true, outputUrl: `/heinzlive/default#${token}` };
+		} catch (cause) {
+			const problem = actionError(cause);
+			return fail(problem.status, { intent: 'createOutput', ...problem });
+		}
+	},
+	rotateOutput: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		try {
+			const token = rotatePresentationChannelKey(text(data, 'showId'));
+			return { intent: 'rotateOutput', success: true, outputUrl: `/heinzlive/default#${token}` };
+		} catch (cause) {
+			const problem = actionError(cause);
+			return fail(problem.status, { intent: 'rotateOutput', ...problem });
+		}
+	},
+	clearOutput: async ({ locals }) => {
+		requireUser(locals.user);
+		return attempt('clearOutput', () => clearPresentationChannel());
+	}
+} satisfies Actions;

src/routes/live/+page.svelte

@@ -1,96 +1,516 @@
 <script lang="ts">
-	import PreviewNotice from '#lib/components/PreviewNotice.svelte';
+	import { enhance, type SubmitFunction } from '$app/forms';
-	import { formatClock } from '#lib/format.js';
 	import { resolve } from '$app/paths';
-	import type { PageData } from './$types';
+	import { onMount, untrack } from 'svelte';
+	import { formatClock, formatDuration } from '#lib/format.js';
+	import AppIcon from '#lib/components/AppIcon.svelte';
+	import type { PageProps } from './$types';
 
-	let { data }: { data: PageData } = $props();
+	let { data, form }: PageProps = $props();
 	let promptSize = $state(1.55);
+	let showRail = $state(true);
+	let showTimes = $state(true);
+	let popupMessage = $state('');
+	let now = $state(Date.now());
+	let loadedAt = $state(Date.now());
+	let currentId = $state(untrack(() => data.live.current?.id ?? null));
+	let loadedRevision = $state(untrack(() => data.live.liveRevision));
+	let outputWindow: Window | null = null;
+	let progress = $derived(
+		data.live.totalCount ? Math.round((data.live.completedCount / data.live.totalCount) * 100) : 0
+	);
+	let currentActualSeconds = $derived(
+		(data.live.current?.actualDurationSeconds ?? 0) +
+			(data.live.current ? Math.max(0, Math.floor((now - loadedAt) / 1000)) : 0)
+	);
+	let sectionElapsedSeconds = $derived(
+		(data.live.sectionTimer?.elapsedSeconds ?? 0) +
+			(data.live.sectionTimer?.runningSinceUtc
+				? Math.max(0, Math.floor((now - loadedAt) / 1000))
+				: 0)
+	);
+	let sectionRemainingSeconds = $derived(
+		(data.live.sectionTimer?.plannedDurationSeconds ?? 0) - sectionElapsedSeconds
+	);
+
+	$effect(() => {
+		const nextCurrentId = data.live.current?.id ?? null;
+		if (nextCurrentId !== currentId || data.live.liveRevision !== loadedRevision) {
+			currentId = nextCurrentId;
+			loadedRevision = data.live.liveRevision;
+			loadedAt = Date.now();
+		}
+	});
+
+	onMount(() => {
+		const key = `sendewerk-live-${data.live.show.id}`;
+		try {
+			const settings = JSON.parse(localStorage.getItem(key) || '{}');
+			if (typeof settings.promptSize === 'number') promptSize = settings.promptSize;
+			if (typeof settings.showRail === 'boolean') showRail = settings.showRail;
+			if (typeof settings.showTimes === 'boolean') showTimes = settings.showTimes;
+			if (typeof settings.scrollY === 'number')
+				requestAnimationFrame(() => scrollTo(0, settings.scrollY));
+		} catch {
+			localStorage.removeItem(key);
+		}
+		const interval = setInterval(() => (now = Date.now()), 1000);
+		const persistScroll = () => persistSettings();
+		addEventListener('scroll', persistScroll, { passive: true });
+		return () => {
+			clearInterval(interval);
+			removeEventListener('scroll', persistScroll);
+		};
+	});
+
+	function persistSettings() {
+		localStorage.setItem(
+			`sendewerk-live-${data.live.show.id}`,
+			JSON.stringify({ promptSize, showRail, showTimes, scrollY })
+		);
+	}
+
+	function changePromptSize(delta: number) {
+		promptSize = Math.min(2.4, Math.max(1.1, promptSize + delta));
+		persistSettings();
+	}
+
+	function toggleRail() {
+		showRail = !showRail;
+		persistSettings();
+	}
+
+	function toggleTimes() {
+		showTimes = !showTimes;
+		persistSettings();
+	}
+
+	function formatCountdown(totalSeconds: number) {
+		const hours = Math.floor(totalSeconds / 3600);
+		const minutes = Math.floor((totalSeconds % 3600) / 60);
+		const seconds = Math.floor(totalSeconds % 60);
+		return hours > 0
+			? `${hours}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`
+			: `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+	}
+
+	function liveAction(name: string) {
+		return `?show=${encodeURIComponent(data.live.show.id)}&/${name}`;
+	}
+
+	const enhanceCommand: SubmitFunction = ({ formElement, formData, submitter }) => {
+		const command = formElement.elements.namedItem('commandId');
+		if (command instanceof HTMLInputElement) {
+			command.value = crypto.randomUUID();
+			formData.set('commandId', command.value);
+		}
+		if (submitter instanceof HTMLButtonElement) submitter.disabled = true;
+		return async ({ update }) => {
+			await update({ reset: false, invalidateAll: true });
+			if (submitter instanceof HTMLButtonElement) submitter.disabled = false;
+		};
+	};
+
+	const enhanceOutput: SubmitFunction = ({ submitter }) => {
+		popupMessage = '';
+		outputWindow = window.open('about:blank', 'heinzlive-output');
+		if (!outputWindow) popupMessage = 'Popup blockiert. Bitte Popups erlauben und erneut öffnen.';
+		if (submitter instanceof HTMLButtonElement) submitter.disabled = true;
+		return async ({ result, update }) => {
+			if (result.type === 'success') {
+				const response = result.data as { outputUrl: string };
+				if (outputWindow && !outputWindow.closed) {
+					outputWindow.location.href = response.outputUrl;
+					popupMessage = 'Präsentationsfenster verbunden.';
+				} else {
+					popupMessage = `Präsentationsfenster konnte nicht geöffnet werden: ${response.outputUrl}`;
+				}
+			} else {
+				outputWindow?.close();
+			}
+			await update({ reset: false, invalidateAll: false });
+			if (submitter instanceof HTMLButtonElement) submitter.disabled = false;
+		};
+	};
 </script>
 
-<svelte:head><title>Live-Vorschau | Sendewerk</title></svelte:head>
+<svelte:head><title>Live | {data.live.show.title} | Sendewerk</title></svelte:head>
 
-<div class="page-wrap live-page">
+<div class="page-wrap live-page live-controller">
 	<header class="live-header">
 		<div>
-			<p class="eyebrow"><span class="live-pulse"></span> Live-Modus · Vorschau</p>
+			<p class="eyebrow"><span class="live-pulse"></span> Live-Steuerung</p>
-			<h1>{data.show.title}</h1>
+			<h1>{data.live.show.title}</h1>
+			<p class="live-state-line">
+				{data.live.startedAtUtc
+					? 'Live-Stand wird automatisch gespeichert.'
+					: 'Noch nicht gestartet.'}
+			</p>
 		</div>
 		<div class="live-header-actions">
 			<div class="font-control" aria-label="Prompter-Schriftgröße">
 				<button
 					type="button"
-					onclick={() => (promptSize = Math.max(1.15, promptSize - 0.1))}
+					onclick={() => changePromptSize(-0.1)}
 					aria-label="Schrift verkleinern">A−</button
 				>
-				<button
+				<button type="button" onclick={() => changePromptSize(0.1)} aria-label="Schrift vergrößern"
-					type="button"
+					>A+</button
-					onclick={() => (promptSize = Math.min(2.1, promptSize + 0.1))}
-					aria-label="Schrift vergrößern">A+</button
 				>
 			</div>
-			<a href={resolve('/sendungen/[id]', { id: data.show.id })}>Planung schließen</a>
+			<button type="button" class="text-button" aria-pressed={!showTimes} onclick={toggleTimes}
+				>{showTimes ? 'Zeiten ausblenden' : 'Zeiten einblenden'}</button
+			>
+			<button type="button" class="text-button" aria-pressed={!showRail} onclick={toggleRail}
+				>{showRail ? 'Ablauf ausblenden' : 'Ablauf einblenden'}</button
+			>
+			<a href={resolve('/sendungen/[id]', { id: data.live.show.id })}>Zur Planung</a>
 		</div>
 	</header>
 
-	<PreviewNotice area="Live-Modus" />
+	{#if form?.error}<div class="form-message error" role="alert">{form.error}</div>{/if}
+	{#if popupMessage}<div class="form-message" role="status">{popupMessage}</div>{/if}
 
-	<div class="live-grid">
+	<section class="live-toolbar" aria-label="Live-Sitzung">
-		{#if data.current}<section class="live-current" style={`--prompt-size: ${promptSize}rem`}>
+		<form method="POST" action={liveAction('start')} use:enhance={enhanceCommand}>
-				<div class="live-kicker">
+			<input type="hidden" name="showId" value={data.live.show.id} />
-					<span>Aktuell · {data.current.section}</span><strong
+			<input type="hidden" name="revision" value={data.live.liveRevision} />
-						>{formatClock(data.current.durationSeconds)}</strong
+			<input type="hidden" name="commandId" value={data.commandId} />
+			<button class="primary-button" type="submit">
+				{data.live.startedAtUtc ? 'Live-Stand wiederaufnehmen' : 'Sendung starten'}
+			</button>
+		</form>
+		<form method="POST" action={liveAction('createOutput')} use:enhance={enhanceOutput}>
+			<input type="hidden" name="showId" value={data.live.show.id} />
+			<button class="secondary-button" type="submit">Ausgabe verbinden und öffnen</button>
+		</form>
+		{#if data.live.presentationUsageId}<form
+				method="POST"
+				action={liveAction('present')}
+				use:enhance={enhanceCommand}
+			>
+				<input type="hidden" name="showId" value={data.live.show.id} />
+				<input type="hidden" name="usageId" value="" />
+				<input type="hidden" name="revision" value={data.live.liveRevision} />
+				<input type="hidden" name="commandId" value={data.commandId} />
+				<button class="text-button" type="submit">Präsentation leeren</button>
+			</form>{/if}
+		<details class="live-output-settings">
+			<summary>Ausgabekanal</summary>
+			<div>
+				<form method="POST" action={liveAction('rotateOutput')} use:enhance={enhanceOutput}>
+					<input type="hidden" name="showId" value={data.live.show.id} />
+					<button class="text-button" type="submit">Schlüssel widerrufen und erneuern</button>
+				</form>
+				<form method="POST" action={liveAction('clearOutput')} use:enhance={enhanceCommand}>
+					<button class="text-button danger-text" type="submit">Ausgabekanal leeren</button>
+				</form>
+			</div>
+		</details>
+		<div class="live-session-summary">
+			<strong>{data.live.completedCount} / {data.live.totalCount}</strong>
+			<span>{progress}% bearbeitet</span>
+		</div>
+	</section>
+
+	<div class:without-rail={!showRail} class="live-grid">
+		{#if data.live.current}<main
+				class="live-current"
+				style={`--prompt-size: ${promptSize}rem`}
+				aria-labelledby="current-title"
+			>
+				{#if data.live.sectionTimer?.sectionId === data.live.current.sectionId}
+					<section
+						class:warning={sectionRemainingSeconds <= 120 && sectionRemainingSeconds >= 0}
+						class:overrun={sectionRemainingSeconds < 0}
+						class="section-countdown"
+						aria-live="off"
 					>
-				</div>
+						<span>{data.live.sectionTimer.sectionName} · Abschnitt</span>
-				<h2>{data.current.title}</h2>
+						<strong
-				<div class="prompter-copy">{data.current.intro}</div>
+							>{sectionRemainingSeconds < 0
-				<div class="moderation-card">
+								? `Überzogen +${formatCountdown(Math.abs(sectionRemainingSeconds))}`
-					<span>Moderationsstichpunkte</span>
+								: `Noch ${formatCountdown(sectionRemainingSeconds)}`}</strong
-					<p>{data.current.moderation}</p>
+						>
-				</div>
+					</section>
-				<details class="research-details">
-					<summary>Recherche öffnen</summary>
-					<p>
-						Die Recherche bleibt im echten Live-Modus standardmäßig geschlossen und bewahrt beim
-						Öffnen die Leseposition.
-					</p>
-				</details>
-				<div class="transition-card">
-					<span>Überleitung</span>
-					<p>{data.current.transition}</p>
-				</div>
-			</section>{:else}<section class="live-current live-empty">
-				<p class="eyebrow">Noch kein Piece eingeplant</p>
-				<h2>Diese Sendung hat noch keinen moderierbaren Inhalt.</h2>
-				<p>In der Planung kann zuerst ein sendefertiges Piece hinzugefügt werden.</p>
-			</section>{/if}
-
-		<aside class="live-rail">
-			<div class="next-card">
-				<span>Als Nächstes</span>
-				{#if data.next}
-					<h3>{data.next.title}</h3>
-					<p>{data.next.section} · {formatClock(data.next.durationSeconds)}</p>
-				{:else}
-					<h3>Sendungsende</h3>
-					<p>Kein weiteres Stück eingeplant.</p>
 				{/if}
-			</div>
+				<div class="live-kicker">
-			<div class="live-progress">
+					<span>Aktuell · {data.live.current.sectionName}</span>
-				<header><span>Ablauf</span><strong>2 / 4</strong></header>
+					{#if showTimes}<strong
-				<div class="progress-track"><span></span></div>
+							>{formatClock(currentActualSeconds)} / {formatClock(
-				{#each data.show.sections as section, index (section.id)}
+								data.live.current.durationSeconds
-					<div class:active={index === 1} class="rail-section">
+							)}</strong
-						<span>{String(index + 1).padStart(2, '0')}</span>
+						>{/if}
+				</div>
+				<h2 id="current-title">{data.live.current.title}</h2>
+				<!-- HTML is produced exclusively by the server-side allowlist sanitizer. -->
+				<!-- eslint-disable-next-line svelte/no-at-html-tags -->
+				<div class="prompter-copy">{@html data.live.current.introHtml}</div>
+				{#if data.live.current.moderationHtml}<section class="moderation-card">
+						<span>Moderationsstichpunkte</span>
+						<!-- eslint-disable-next-line svelte/no-at-html-tags -->
+						<div class="live-markdown">{@html data.live.current.moderationHtml}</div>
+					</section>{/if}
+				<details class="research-details">
+					<summary>Manuelle Recherche öffnen</summary>
+					<!-- eslint-disable-next-line svelte/no-at-html-tags -->
+					<div class="live-markdown">{@html data.live.current.researchHtml}</div>
+				</details>
+				{#if data.live.current.sources.length || data.live.current.tools.length}
+					<!-- eslint-disable svelte/no-navigation-without-resolve -->
+					<section class="live-materials" aria-labelledby="live-materials-title">
 						<div>
-							<strong>{section.name}</strong><small>{formatClock(section.durationSeconds)}</small>
+							<span>Nur Redaktion</span>
+							<h3 id="live-materials-title">Materialien</h3>
 						</div>
-					</div>
+						{#if data.live.current.sources.length}<div class="live-material-group">
-				{/each}
+								<strong>Quellen</strong>
-			</div>
+								<ul>
-			<div class="readonly-actions" aria-label="Spätere Live-Aktionen">
+									{#each data.live.current.sources as source (source.id)}<li>
-				<span>Zurück</span><strong>In Etappe 5 steuerbar</strong><span>Erledigen</span>
+											<!-- The URL is a server-validated private HTTP(S) snapshot. -->
-			</div>
+											<!-- eslint-disable-next-line svelte/no-navigation-without-resolve -->
-		</aside>
+											<a href={source.url} target="_blank" rel="noopener noreferrer"
+												>{source.label}</a
+											>{#if source.timecodeSeconds !== null}<small
+													>ab {formatClock(source.timecodeSeconds)}</small
+												>{/if}
+										</li>{/each}
+								</ul>
+							</div>{/if}
+						{#if data.live.current.tools.length}<div class="live-material-group">
+								<strong>Werkzeuge</strong>
+								<ul>
+									{#each data.live.current.tools as tool (tool.id)}<li>
+											{#if tool.workUrl || tool.startUrl}<!-- The URL is a server-validated private HTTP(S) snapshot. -->
+												<!-- eslint-disable-next-line svelte/no-navigation-without-resolve -->
+												<a
+													href={tool.workUrl || tool.startUrl}
+													target="_blank"
+													rel="noopener noreferrer">{tool.name}</a
+												>{:else}<span>{tool.name}</span><small>Kein Link hinterlegt</small>{/if}
+											{#if tool.note}<small>{tool.note}</small>{/if}
+										</li>{/each}
+								</ul>
+							</div>{/if}
+					</section>
+					<!-- eslint-enable svelte/no-navigation-without-resolve -->
+				{/if}
+				{#if data.live.current.transitionHtml}<section class="transition-card">
+						<span>Überleitung</span>
+						<!-- eslint-disable-next-line svelte/no-at-html-tags -->
+						<div class="live-markdown">{@html data.live.current.transitionHtml}</div>
+					</section>{/if}
+
+				<div class="live-current-actions">
+					<form method="POST" action={liveAction('back')} use:enhance={enhanceCommand}>
+						<input type="hidden" name="showId" value={data.live.show.id} />
+						<input type="hidden" name="revision" value={data.live.liveRevision} />
+						<input type="hidden" name="commandId" value={data.commandId} />
+						<button class="secondary-button" type="submit">Zurück</button>
+					</form>
+					<form method="POST" action={liveAction('present')} use:enhance={enhanceCommand}>
+						<input type="hidden" name="showId" value={data.live.show.id} />
+						<input type="hidden" name="usageId" value={data.live.current.id} />
+						<input type="hidden" name="revision" value={data.live.liveRevision} />
+						<input type="hidden" name="commandId" value={data.commandId} />
+						<button class="secondary-button" type="submit">
+							{data.live.presentationUsageId === data.live.current.id
+								? 'Erneut präsentieren'
+								: 'Präsentieren'}
+						</button>
+					</form>
+					<form method="POST" action={liveAction('skip')} use:enhance={enhanceCommand}>
+						<input type="hidden" name="showId" value={data.live.show.id} />
+						<input type="hidden" name="revision" value={data.live.liveRevision} />
+						<input type="hidden" name="commandId" value={data.commandId} />
+						<button class="text-button" type="submit">Überspringen</button>
+					</form>
+					<form method="POST" action={liveAction('complete')} use:enhance={enhanceCommand}>
+						<input type="hidden" name="showId" value={data.live.show.id} />
+						<input type="hidden" name="revision" value={data.live.liveRevision} />
+						<input type="hidden" name="commandId" value={data.commandId} />
+						<button class="primary-button" type="submit">Erledigen und weiter</button>
+					</form>
+				</div>
+			</main>{:else}<main class="live-current live-empty">
+				<p class="eyebrow">Kein aktives Piece</p>
+				<h2>{data.live.totalCount ? 'Live-Stand bereit' : 'Noch kein Piece eingeplant'}</h2>
+				<p>
+					{data.live.totalCount
+						? 'Sendung starten oder einen abgeschlossenen Schritt zurückgehen.'
+						: 'In der Planung kann zuerst ein sendefertiges Piece hinzugefügt werden.'}
+				</p>
+				{#if data.live.completedCount}<form
+						method="POST"
+						action={liveAction('back')}
+						use:enhance={enhanceCommand}
+					>
+						<input type="hidden" name="showId" value={data.live.show.id} />
+						<input type="hidden" name="revision" value={data.live.liveRevision} />
+						<input type="hidden" name="commandId" value={data.commandId} />
+						<button class="secondary-button" type="submit">Zum letzten Piece zurück</button>
+					</form>{/if}
+			</main>{/if}
+
+		{#if showRail}<aside class="live-rail">
+				<section class="next-card">
+					<span>Als Nächstes</span>
+					{#if data.live.next}
+						<h3>{data.live.next.title}</h3>
+						<p>
+							{data.live.next.sectionName}{#if showTimes}
+								· {formatClock(data.live.next.durationSeconds)}{/if}
+						</p>
+					{:else}
+						<h3>Sendungsende</h3>
+						<p>Kein weiteres offenes Piece eingeplant.</p>
+					{/if}
+				</section>
+
+				<section class="live-progress">
+					<header>
+						<span>Ablauf</span><strong>{data.live.completedCount} / {data.live.totalCount}</strong>
+					</header>
+					<div class="progress-track"><span style={`width:${progress}%`}></span></div>
+					{#each data.live.sections as section, sectionIndex (section.id)}
+						<div class:active={section.id === data.live.current?.sectionId} class="rail-section">
+							<span>{String(sectionIndex + 1).padStart(2, '0')}</span>
+							<div>
+								<strong>{section.name}</strong>
+								{#if showTimes}<small>{formatDuration(section.durationSeconds)}</small>{/if}
+							</div>
+						</div>
+						{#each section.usages as usage, usageIndex (usage.id)}
+							<div class:current={usage.id === data.live.current?.id} class="live-run-item">
+								<div>
+									<strong>{usage.title}</strong><small>{usage.status}</small>
+								</div>
+								<div class="live-run-actions">
+									<form method="POST" action={liveAction('select')} use:enhance={enhanceCommand}>
+										<input type="hidden" name="showId" value={data.live.show.id} />
+										<input type="hidden" name="usageId" value={usage.id} />
+										<input type="hidden" name="revision" value={data.live.liveRevision} />
+										<input type="hidden" name="commandId" value={data.commandId} />
+										<button
+											class="text-button"
+											type="submit"
+											disabled={!data.live.startedAtUtc || usage.id === data.live.current?.id}
+											aria-label={`${usage.title} als aktuelles Piece auswählen`}>Aktuell</button
+										>
+									</form>
+									{#if usage.status === 'open'}
+										<form
+											method="POST"
+											action={liveAction('moveUsage')}
+											use:enhance={enhanceCommand}
+										>
+											<input type="hidden" name="showId" value={data.live.show.id} />
+											<input type="hidden" name="showRevision" value={data.live.show.revision} />
+											<input type="hidden" name="usageId" value={usage.id} />
+											<input type="hidden" name="sectionId" value={section.id} />
+											<input type="hidden" name="position" value={usageIndex - 1} />
+											<button
+												type="submit"
+												disabled={usageIndex === 0 ||
+													section.usages[usageIndex - 1]?.status !== 'open'}
+												aria-label={`${usage.title} nach oben`}><AppIcon name="arrow-up" /></button
+											>
+										</form>
+										<form
+											method="POST"
+											action={liveAction('moveUsage')}
+											use:enhance={enhanceCommand}
+										>
+											<input type="hidden" name="showId" value={data.live.show.id} />
+											<input type="hidden" name="showRevision" value={data.live.show.revision} />
+											<input type="hidden" name="usageId" value={usage.id} />
+											<input type="hidden" name="sectionId" value={section.id} />
+											<input type="hidden" name="position" value={usageIndex + 1} />
+											<button
+												type="submit"
+												disabled={usageIndex === section.usages.length - 1 ||
+													section.usages[usageIndex + 1]?.status !== 'open'}
+												aria-label={`${usage.title} nach unten`}
+												><AppIcon name="arrow-down" /></button
+											>
+										</form>
+									{/if}
+									<form method="POST" action={liveAction('present')} use:enhance={enhanceCommand}>
+										<input type="hidden" name="showId" value={data.live.show.id} />
+										<input type="hidden" name="usageId" value={usage.id} />
+										<input type="hidden" name="revision" value={data.live.liveRevision} />
+										<input type="hidden" name="commandId" value={data.commandId} />
+										<button type="submit" aria-label={`${usage.title} präsentieren`}
+											><AppIcon name="display" /></button
+										>
+									</form>
+								</div>
+							</div>
+						{/each}
+					{/each}
+				</section>
+
+				<section class="live-reserve">
+					<header><span>Reserve</span><strong>{data.live.reserve.length}</strong></header>
+					{#each data.live.reserve as usage, reserveIndex (usage.id)}
+						<div class="live-reserve-item">
+							<div>
+								<strong>{usage.title}</strong>{#if showTimes}<small
+										>{formatClock(usage.durationSeconds)}</small
+									>{/if}
+							</div>
+							<div class="live-run-actions">
+								<form method="POST" action={liveAction('moveUsage')} use:enhance={enhanceCommand}>
+									<input type="hidden" name="showId" value={data.live.show.id} />
+									<input type="hidden" name="showRevision" value={data.live.show.revision} />
+									<input type="hidden" name="usageId" value={usage.id} />
+									<input type="hidden" name="sectionId" value="" />
+									<input type="hidden" name="position" value={reserveIndex - 1} />
+									<button
+										type="submit"
+										disabled={reserveIndex === 0}
+										aria-label={`${usage.title} in Reserve nach oben`}
+										><AppIcon name="arrow-up" /></button
+									>
+								</form>
+								<form method="POST" action={liveAction('moveUsage')} use:enhance={enhanceCommand}>
+									<input type="hidden" name="showId" value={data.live.show.id} />
+									<input type="hidden" name="showRevision" value={data.live.show.revision} />
+									<input type="hidden" name="usageId" value={usage.id} />
+									<input type="hidden" name="sectionId" value="" />
+									<input type="hidden" name="position" value={reserveIndex + 1} />
+									<button
+										type="submit"
+										disabled={reserveIndex === data.live.reserve.length - 1}
+										aria-label={`${usage.title} in Reserve nach unten`}
+										><AppIcon name="arrow-down" /></button
+									>
+								</form>
+								{#if data.live.current || data.live.sections[0]}<form
+										method="POST"
+										action={liveAction('moveUsage')}
+										use:enhance={enhanceCommand}
+									>
+										<input type="hidden" name="showId" value={data.live.show.id} />
+										<input type="hidden" name="showRevision" value={data.live.show.revision} />
+										<input type="hidden" name="usageId" value={usage.id} />
+										<input
+											type="hidden"
+											name="sectionId"
+											value={data.live.current?.sectionId ?? data.live.sections[0]?.id}
+										/>
+										<input
+											type="hidden"
+											name="position"
+											value={(data.live.current?.position ?? -1) + 1}
+										/>
+										<button class="text-button" type="submit">Als Nächstes</button>
+									</form>{/if}
+							</div>
+						</div>
+					{/each}
+					{#if !data.live.reserve.length}<p>Keine Pieces in Reserve.</p>{/if}
+				</section>
+			</aside>{/if}
 	</div>
 </div>

src/routes/sendungen/+page.svelte

@@ -1,6 +1,7 @@
 <script lang="ts">
 	import { resolve } from '$app/paths';
 	import { formatDuration } from '#lib/format.js';
+	import AppIcon from '#lib/components/AppIcon.svelte';
 	import type { PageProps } from './$types';
 
 	let { data, form }: PageProps = $props();
@@ -27,8 +28,9 @@
 
 	{#if form?.error}<div class="form-message error" role="alert">{form.error}</div>{/if}
 
-	<section class="show-create-panel">
+	<details class="show-create-panel">
-		<div>
+		<summary><AppIcon name="plus" /> Neue Sendung planen</summary>
+		<div class="show-create-heading">
 			<p class="eyebrow">Neuen Stream planen</p>
 			<h2>Leer starten oder Ablauf übernehmen</h2>
 		</div>
@@ -45,23 +47,29 @@
 			<label
 				>Termin<input name="startsAt" type="datetime-local" value={form?.startsAt ?? ''} /></label
 			>
-			<label
+			<fieldset class="show-template-grid">
-				>Ausgangspunkt<select name="templateId" value={form?.templateId ?? ''}
+				<legend>Ausgangspunkt</legend>
-					><option value="">Leer starten</option
+				<label
-					>{#each data.templates as template (template.id)}<option value={template.id}
+					><input type="radio" name="templateId" value="" checked={!form?.templateId} /><AppIcon
-							>{template.name}</option
+						name="newspaper"
-						>{/each}</select
+					/><span
-				></label
+						><strong>Leer starten</strong><small>Eine leere Sendung frei aufbauen.</small></span
-			>
+					></label
+				>
+				{#each data.templates as template (template.id)}<label
+						><input
+							type="radio"
+							name="templateId"
+							value={template.id}
+							checked={form?.templateId === template.id}
+						/><AppIcon name="list-check" /><span
+							><strong>{template.name}</strong><small>{template.description}</small></span
+						></label
+					>{/each}
+			</fieldset>
 			<button class="primary-button" type="submit">Sendung anlegen</button>
 		</form>
-		<div class="template-notes">
+	</details>
-			{#each data.templates as template (template.id)}<p>
-					<strong>{template.name}:</strong>
-					{template.description}
-				</p>{/each}
-		</div>
-	</section>
 
 	<section class="show-library" aria-labelledby="show-library-title">
 		<header>
@@ -86,16 +94,17 @@
 							<p>{berlinDate(show.startsAtUtc)} Uhr</p>
 						</div>
 						<div class="show-card-facts">
-							<span><strong>{show.sectionCount}</strong> Abschnitte</span><span
+							{#if show.sectionCount}<span><strong>{show.sectionCount}</strong> Abschnitte</span
-								><strong>{formatDuration(show.totalDurationSeconds)}</strong> Planzeit</span
+								>{/if}{#if show.totalDurationSeconds}<span
-							><b aria-hidden="true">→</b>
+									><strong>{formatDuration(show.totalDurationSeconds)}</strong> Planzeit</span
+								>{/if}<b aria-hidden="true"><AppIcon name="arrow-right" /></b>
 						</div>
 					</a>
 				{/each}
 			</div>
 		{:else}
 			<div class="empty-state">
-				<span aria-hidden="true">＋</span>
+				<span aria-hidden="true"><AppIcon name="plus" /></span>
 				<h2>Noch keine Sendung</h2>
 				<p>Oben kann der erste Stream geplant werden.</p>
 			</div>

src/routes/sendungen/[id]/+page.server.ts

@@ -1,20 +1,25 @@
+import { randomUUID } from 'node:crypto';
 import { error, fail } from '@sveltejs/kit';
 import type { Actions, PageServerLoad } from './$types';
 import { requireUser } from '#lib/server/auth.js';
-import { getTaxonomy, listPieces } from '#lib/server/content.js';
+import { getTaxonomy, listPieces, listPieceTemplates } from '#lib/server/content.js';
 import {
 	addPieceUsage,
 	addShowSection,
+	createAndAddPieceUsage,
+	duplicatePieceUsage,
 	getShow,
+	getPieceUsageContexts,
 	movePieceUsage,
 	moveShowSection,
+	refreshPieceUsageFromOriginal,
 	removePieceUsage,
 	removeShowSection,
 	saveShowMetadata,
 	updatePieceUsage,
 	updateShowSection,
 	type EditableShowStatus,
-	type UsageStatus
+	type PieceUsageUpdate
 } from '#lib/server/shows.js';
 
 function text(data: FormData, name: string) {
@@ -84,7 +89,19 @@ function actionError(cause: unknown) {
 		return { status: 409, error: 'Abgeschlossene Sendungen können nicht bearbeitet werden.' };
 	if (code === 'PIECE_NOT_READY')
 		return { status: 400, error: 'Nur sendefertige Pieces können eingeplant werden.' };
+	if (code === 'ORIGINAL_NOT_FOUND')
+		return { status: 409, error: 'Das zugehörige Fundus-Piece ist nicht mehr verfügbar.' };
 	if (code === 'NOT_FOUND') return { status: 404, error: 'Der Eintrag wurde nicht gefunden.' };
+	if (
+		['USAGE_IS_CURRENT', 'USAGE_IS_PRESENTED', 'USAGE_HAS_LIVE_RUNS', 'USAGE_NOT_OPEN'].includes(
+			code
+		)
+	)
+		return {
+			status: 409,
+			error:
+				'Diese Sendungsfassung war bereits live aktiv oder wird gerade verwendet und kann nicht entfernt werden.'
+		};
 	if (code === 'INVALID_DURATION')
 		return { status: 400, error: 'Piece-Dauern müssen zwischen 0 und 1.440 Minuten liegen.' };
 	if (code.startsWith('INVALID_'))
@@ -104,18 +121,27 @@ export const load: PageServerLoad = ({ locals, params, url }) => {
 	requireUser(locals.user);
 	const show = getShow(params.id);
 	if (!show) error(404, 'Sendung nicht gefunden');
+	const pieces = listPieces({
+		statuses: ['ready'],
+		query: url.searchParams.get('q') ?? '',
+		categoryId: url.searchParams.get('category') ?? ''
+	});
+	const usageContexts = getPieceUsageContexts(
+		pieces.map((piece) => piece.id),
+		show.id
+	);
 	return {
 		show,
 		startsAtLocal: berlinInput(show.startsAtUtc),
-		pieces: listPieces({
+		pieces: pieces.map((piece) => ({ ...piece, ...usageContexts[piece.id] })),
-			statuses: ['ready'],
-			query: url.searchParams.get('q') ?? '',
-			categoryId: url.searchParams.get('category') ?? ''
-		}),
 		taxonomy: getTaxonomy(),
+		pieceTemplates: listPieceTemplates(),
+		createCommandId: randomUUID(),
 		filters: {
 			query: url.searchParams.get('q') ?? '',
-			categoryId: url.searchParams.get('category') ?? ''
+			categoryId: url.searchParams.get('category') ?? '',
+			includeUsed: url.searchParams.get('includeUsed') === '1',
+			includePlanned: url.searchParams.get('includePlanned') === '1'
 		}
 	};
 };
@@ -185,12 +211,27 @@ export const actions = {
 			})
 		);
 	},
+	createUsage: async ({ locals, params, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		return attempt('createUsage', () =>
+			createAndAddPieceUsage(params.id, Number(data.get('revision')), text(data, 'commandId'), {
+				title: text(data, 'title'),
+				templateId: text(data, 'templateId') || 'blank',
+				sectionId: text(data, 'sectionId') || null
+			})
+		);
+	},
 	updateUsage: async ({ locals, params, request }) => {
 		requireUser(locals.user);
 		const data = await request.formData();
+		const toolIds = data.getAll('usageToolId').map(String);
+		const toolWorkUrls = data.getAll('toolWorkUrl').map(String);
+		const toolNotes = data.getAll('toolNote').map(String);
 		return attempt('updateUsage', () =>
 			updatePieceUsage(params.id, text(data, 'usageId'), Number(data.get('revision')), {
 				title: text(data, 'title'),
+				outputTitle: text(data, 'outputTitle'),
 				durationSeconds: pieceDurationInSeconds(data),
 				ownNotes: text(data, 'ownNotes'),
 				intro: text(data, 'intro'),
@@ -198,10 +239,39 @@ export const actions = {
 				moderation: text(data, 'moderation'),
 				transition: text(data, 'transition'),
 				presentation: text(data, 'presentation'),
-				status: text(data, 'status') as UsageStatus
+				presentationMode: text(data, 'presentationMode') as PieceUsageUpdate['presentationMode'],
+				presentationSourceLabel: text(data, 'presentationSourceLabel'),
+				presentationSourceUrl: text(data, 'presentationSourceUrl'),
+				presentationSourceTimecodeSeconds: text(data, 'presentationSourceTimecodeSeconds')
+					? Number(data.get('presentationSourceTimecodeSeconds'))
+					: null,
+				presentationTitle: text(data, 'presentationTitle'),
+				presentationDescription: text(data, 'presentationDescription'),
+				presentationImageUrl: text(data, 'presentationImageUrl'),
+				presentationSiteName: text(data, 'presentationSiteName'),
+				presentationMediaId: text(data, 'presentationMediaId') || null,
+				tools: toolIds.map((id, index) => ({
+					id,
+					workUrl: toolWorkUrls[index] ?? '',
+					note: toolNotes[index] ?? ''
+				}))
 			})
 		);
 	},
+	duplicateUsage: async ({ locals, params, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		return attempt('duplicateUsage', () =>
+			duplicatePieceUsage(params.id, text(data, 'usageId'), Number(data.get('revision')))
+		);
+	},
+	refreshUsage: async ({ locals, params, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		return attempt('refreshUsage', () =>
+			refreshPieceUsageFromOriginal(params.id, text(data, 'usageId'), Number(data.get('revision')))
+		);
+	},
 	removeUsage: async ({ locals, params, request }) => {
 		requireUser(locals.user);
 		const data = await request.formData();

src/routes/sendungen/[id]/+page.svelte

@@ -1,7 +1,13 @@
 <script lang="ts">
 	import { enhance, type SubmitFunction } from '$app/forms';
+	import { replaceState } from '$app/navigation';
 	import { resolve } from '$app/paths';
+	import { page } from '$app/state';
 	import { flip } from 'svelte/animate';
+	import { onMount, untrack } from 'svelte';
+	import PieceUsageHistory from '#lib/components/PieceUsageHistory.svelte';
+	import AppIcon from '#lib/components/AppIcon.svelte';
+	import UsageEditorDialog from '#lib/components/UsageEditorDialog.svelte';
 	import { formatClock, formatDuration } from '#lib/format.js';
 	import type { PageProps } from './$types';
 
@@ -17,15 +23,35 @@
 	let moveSectionForm: HTMLFormElement;
 	let moveUsageForm: HTMLFormElement;
 	let addUsageForm: HTMLFormElement;
+	let removeUsageForm: HTMLFormElement;
 	let draggedSectionId = $state('');
 	let draggedUsageId = $state('');
 	let draggedPieceId = $state('');
+	let removedUsageId = $state('');
 	let dropSectionId = $state('');
 	let dropPosition = $state(0);
 	let copyMessage = $state('');
+	let showUsedPieces = $state(untrack(() => data.filters.includeUsed));
+	let showPlannedPieces = $state(untrack(() => data.filters.includePlanned));
+	let visiblePieces = $derived(
+		data.pieces.filter(
+			(piece) =>
+				(showUsedPieces || piece.sentHistory.length === 0 || piece.isFavorite) &&
+				(showPlannedPieces || !piece.isPlannedInCurrentShow)
+		)
+	);
 	let plannedCount = $derived(
 		data.show.sections.reduce((total, section) => total + section.usages.length, 0)
 	);
+	onMount(() => {
+		const syncFiltersFromHistory = () => {
+			const search = new URL(window.location.href).searchParams;
+			showUsedPieces = search.get('includeUsed') === '1';
+			showPlannedPieces = search.get('includePlanned') === '1';
+		};
+		window.addEventListener('popstate', syncFiltersFromHistory);
+		return () => window.removeEventListener('popstate', syncFiltersFromHistory);
+	});
 
 	function berlinDate(value: string | null) {
 		if (!value) return 'Termin offen';
@@ -36,8 +62,15 @@
 		}).format(new Date(value));
 	}
 
-	function durationInMinutes(seconds: number) {
+	function setSourceFilter(name: 'includeUsed' | 'includePlanned', checked: boolean) {
-		return Number((seconds / 60).toFixed(2));
+		if (name === 'includeUsed') showUsedPieces = checked;
+		else showPlannedPieces = checked;
+		const url = new URL(page.url.href);
+		if (checked) url.searchParams.set(name, '1');
+		else url.searchParams.delete(name);
+		// This URL is cloned from the current page; only same-route filter parameters change.
+		// eslint-disable-next-line svelte/no-navigation-without-resolve
+		replaceState(url, page.state);
 	}
 
 	function startDrag(kind: 'piece' | 'section' | 'usage', id: string, event: DragEvent) {
@@ -135,6 +168,17 @@
 		setTimeout(() => moveUsageForm.requestSubmit());
 	}
 
+	function removeDraggedUsage() {
+		if (dragged?.kind !== 'usage') return;
+		if (!confirm('Piece aus dieser Sendung entfernen?')) {
+			finishDrag();
+			return;
+		}
+		removedUsageId = dragged.id;
+		finishDrag();
+		setTimeout(() => removeUsageForm.requestSubmit());
+	}
+
 	const enhanceCommand: SubmitFunction = ({ formElement, submitter }) => {
 		const affected = formElement.closest<HTMLElement>(
 			'.run-section, .editable-reserve, .builder-source-card, .show-settings, .add-section-form'
@@ -142,6 +186,7 @@
 		affected?.classList.add('is-updating');
 		if (submitter instanceof HTMLButtonElement) submitter.disabled = true;
 		return async ({ result, update }) => {
+			if (result.type === 'success') formElement.closest<HTMLDialogElement>('dialog')?.close();
 			await update({ reset: result.type === 'success', invalidateAll: true });
 			affected?.classList.remove('is-updating');
 			if (submitter instanceof HTMLButtonElement) submitter.disabled = false;
@@ -163,7 +208,7 @@
 <div class="page-wrap builder-page">
 	<header class="page-heading show-heading">
 		<div class="show-heading-copy">
-			<a class="back-link" href={resolve('/sendungen')}>← Sendungen</a>
+			<a class="back-link" href={resolve('/sendungen')}><AppIcon name="arrow-left" /> Sendungen</a>
 			<h1>{data.show.title}</h1>
 			<p class="show-date">
 				{data.show.startsAtUtc ? `${berlinDate(data.show.startsAtUtc)} Uhr` : 'Termin offen'}
@@ -175,7 +220,7 @@
 				<strong>{formatDuration(data.show.totalDurationSeconds)}</strong><span>Planzeit</span>
 			</div>
 			<a class="live-link" href={resolve(`/live?show=${encodeURIComponent(data.show.id)}`)}
-				>Live-Vorschau <span>↗</span></a
+				>Live-Steuerung <AppIcon name="display" /></a
 			>
 		</div>
 	</header>
@@ -256,17 +301,54 @@
 	<div class="builder-workspace">
 		<section
 			class="builder-pane source-pane"
+			class:drop-ready={dropTarget === 'source'}
 			class:mobile-hidden={mobilePane !== 'fundus'}
 			aria-labelledby="source-title"
+			ondragover={(event) => {
+				if (dragged?.kind !== 'usage') return;
+				event.preventDefault();
+				dropTarget = 'source';
+			}}
+			ondrop={(event) => {
+				event.preventDefault();
+				removeDraggedUsage();
+			}}
 		>
 			<header class="pane-heading">
 				<div>
 					<p class="eyebrow">Quelle</p>
 					<h2 id="source-title">Sendefertiger Fundus</h2>
 				</div>
-				<span>{data.pieces.length}</span>
+				<span>{visiblePieces.length}</span>
 			</header>
-			<form method="GET" class="builder-filter">
+			{#if dropTarget === 'source'}<div class="drag-remove-target">
+					<strong>Aus Sendung entfernen</strong><span>Das Fundus-Original bleibt erhalten.</span>
+				</div>{/if}
+			<details class="plan-piece-create">
+				<summary>Neues Piece direkt einplanen</summary>
+				<form use:enhance={enhanceCommand} method="POST" action="?/createUsage">
+					<input type="hidden" name="revision" value={data.show.revision} />
+					<input type="hidden" name="commandId" value={data.createCommandId} />
+					<label>Titel<input name="title" required maxlength="200" /></label>
+					<label
+						>Vorlage<select name="templateId">
+							{#each data.pieceTemplates as template (template.id)}<option value={template.id}
+									>{template.name}</option
+								>{/each}
+						</select></label
+					>
+					<label
+						>Ziel<select name="sectionId">
+							<option value="">Reservebank</option>
+							{#each data.show.sections as section (section.id)}<option value={section.id}
+									>{section.name}</option
+								>{/each}
+						</select></label
+					>
+					<button class="secondary-button" type="submit">Anlegen und einplanen</button>
+				</form>
+			</details>
+			<form id="builder-filters" method="GET" class="builder-filter">
 				<label
 					><span class="sr-only">Fundus durchsuchen</span><input
 						type="search"
@@ -286,8 +368,32 @@
 				>
 				<button class="text-button" type="submit">Filtern</button>
 			</form>
+			<div class="builder-filter-options" aria-label="Fundusauswahl erweitern">
+				<label class="filter-checkbox">
+					<input
+						type="checkbox"
+						name="includeUsed"
+						value="1"
+						form="builder-filters"
+						checked={showUsedPieces}
+						onchange={(event) => setSourceFilter('includeUsed', event.currentTarget.checked)}
+					/>
+					<span>Auch verwendete Inhalte zeigen</span>
+				</label>
+				<label class="filter-checkbox">
+					<input
+						type="checkbox"
+						name="includePlanned"
+						value="1"
+						form="builder-filters"
+						checked={showPlannedPieces}
+						onchange={(event) => setSourceFilter('includePlanned', event.currentTarget.checked)}
+					/>
+					<span>Auch eingeplante Inhalte zeigen</span>
+				</label>
+			</div>
 			<div class="builder-source-list">
-				{#each data.pieces as piece (piece.id)}
+				{#each visiblePieces as piece (piece.id)}
 					<article
 						class="builder-source-card"
 						class:is-dragging={dragged?.kind === 'piece' && dragged.id === piece.id}
@@ -306,10 +412,16 @@
 									><i></i>{piece.categories.map((item) => item.name).join(', ') || 'Offen'}</span
 								><span>{formatClock(piece.durationSeconds)}</span>
 							</div>
-							<h3>{piece.title}</h3>
+							<h3>
+								{#if piece.isFavorite}<span class="favorite-mark" aria-label="Favorit"
+										><AppIcon name="star" /></span
+									>{/if}{piece.title}
+							</h3>
 							<p>
 								{piece.format} · {piece.topics.map((item) => item.name).join(', ') || 'Ohne Thema'}
 							</p>
+							{#if piece.isPlannedInCurrentShow}<span class="planned-label">Eingeplant</span>{/if}
+							<PieceUsageHistory history={piece.sentHistory} />
 							<small class="drag-hint">Ziehen oder Ziel auswählen</small>
 						</div>
 						<form
@@ -338,10 +450,13 @@
 					</article>
 				{/each}
 			</div>
-			{#if !data.pieces.length}<div class="empty-state">
+			{#if !visiblePieces.length}<div class="empty-state">
-					<span aria-hidden="true">⌕</span>
+					<span aria-hidden="true"><AppIcon name="magnifying-glass" /></span>
-					<h2>Nichts gefunden</h2>
+					<h2>Keine verfügbaren Pieces</h2>
-					<p>Filter ändern oder Pieces im Fundus sendefertig markieren.</p>
+					<p>
+						Suchfilter ändern, ausgeblendete Inhalte einblenden oder Pieces im Fundus sendefertig
+						markieren.
+					</p>
 				</div>{/if}
 		</section>
 
@@ -412,7 +527,7 @@
 									/><input type="hidden" name="position" value={index - 1} /><button
 										type="submit"
 										disabled={index === 0}
-										aria-label={`${section.name} nach oben`}>↑</button
+										aria-label={`${section.name} nach oben`}><AppIcon name="arrow-up" /></button
 									>
 								</form>
 								<form use:enhance={enhanceCommand} method="POST" action="?/moveSection">
@@ -423,7 +538,7 @@
 									/><input type="hidden" name="position" value={index + 1} /><button
 										type="submit"
 										disabled={index === data.show.sections.length - 1}
-										aria-label={`${section.name} nach unten`}>↓</button
+										aria-label={`${section.name} nach unten`}><AppIcon name="arrow-down" /></button
 									>
 								</form>
 							</div>
@@ -473,7 +588,7 @@
 													ondragend={finishDrag}
 												>
 													<strong>{usage.title}</strong><small
-														>{formatClock(usage.durationSeconds)} · sendungsspezifische Kopie</small
+														>{formatClock(usage.durationSeconds)}</small
 													>
 												</div>
 												<div class="row-actions">
@@ -489,7 +604,8 @@
 														/><button
 															type="submit"
 															disabled={usageIndex === 0}
-															aria-label={`${usage.title} nach oben`}>↑</button
+															aria-label={`${usage.title} nach oben`}
+															><AppIcon name="arrow-up" /></button
 														>
 													</form>
 													<form use:enhance={enhanceCommand} method="POST" action="?/moveUsage">
@@ -504,108 +620,19 @@
 														/><button
 															type="submit"
 															disabled={usageIndex === section.usages.length - 1}
-															aria-label={`${usage.title} nach unten`}>↓</button
+															aria-label={`${usage.title} nach unten`}
+															><AppIcon name="arrow-down" /></button
 														>
 													</form>
+													<UsageEditorDialog
+														{usage}
+														revision={data.show.revision}
+														sectionId={section.id}
+														sections={data.show.sections}
+														error={form?.error}
+														{enhanceCommand}
+													/>
 												</div>
-												<details class="usage-editor">
-													<summary>Bearbeiten und verschieben</summary>
-													<form
-														use:enhance={enhanceCommand}
-														method="POST"
-														action="?/updateUsage"
-														class="usage-edit-form"
-													>
-														<input type="hidden" name="revision" value={data.show.revision} /><input
-															type="hidden"
-															name="usageId"
-															value={usage.id}
-														/>
-														<label
-															>Titel<input
-																name="title"
-																required
-																maxlength="200"
-																value={usage.title}
-															/></label
-														><label
-															>Dauer in Minuten<input
-																name="durationMinutes"
-																type="number"
-																min="0"
-																max="1440"
-																step="any"
-																value={durationInMinutes(usage.durationSeconds)}
-															/></label
-														>
-														<label class="wide-field"
-															>Eigene Notizen<textarea name="ownNotes" rows="2"
-																>{usage.ownNotes}</textarea
-															></label
-														><label class="wide-field"
-															>Einleitung<textarea name="intro" rows="2">{usage.intro}</textarea
-															></label
-														><label class="wide-field"
-															>Recherche<textarea name="research" rows="2"
-																>{usage.research}</textarea
-															></label
-														><label class="wide-field"
-															>Moderation<textarea name="moderation" rows="2"
-																>{usage.moderation}</textarea
-															></label
-														><label class="wide-field"
-															>Überleitung<textarea name="transition" rows="2"
-																>{usage.transition}</textarea
-															></label
-														><label class="wide-field"
-															>Präsentation<textarea name="presentation" rows="2"
-																>{usage.presentation}</textarea
-															></label
-														>
-														<input type="hidden" name="status" value={usage.status} /><button
-															class="primary-button wide-field"
-															type="submit">Verwendung speichern</button
-														>
-													</form>
-													<div class="usage-command-row">
-														<form use:enhance={enhanceCommand} method="POST" action="?/moveUsage">
-															<input
-																type="hidden"
-																name="revision"
-																value={data.show.revision}
-															/><input type="hidden" name="usageId" value={usage.id} /><input
-																type="hidden"
-																name="position"
-																value="9999"
-															/><label
-																>Ziel<select name="sectionId"
-																	><option value="">Reservebank</option
-																	>{#each data.show.sections as target (target.id)}<option
-																			value={target.id}
-																			selected={target.id === section.id}>{target.name}</option
-																		>{/each}</select
-																></label
-															><button class="secondary-button" type="submit">Verschieben</button>
-														</form>
-														<form
-															use:enhance={enhanceCommand}
-															method="POST"
-															action="?/removeUsage"
-															onsubmit={(event) =>
-																!confirm('Verwendung aus der Sendung entfernen?') &&
-																event.preventDefault()}
-														>
-															<input
-																type="hidden"
-																name="revision"
-																value={data.show.revision}
-															/><input type="hidden" name="usageId" value={usage.id} /><button
-																class="text-button danger-text"
-																type="submit">Entfernen</button
-															>
-														</form>
-													</div>
-												</details>
 											</div>
 										</div>
 									{/each}
@@ -800,7 +827,13 @@
 									></label
 								><button class="secondary-button" type="submit">Einplanen</button>
 							</form>
-							<form use:enhance={enhanceCommand} method="POST" action="?/removeUsage">
+							<form
+								use:enhance={enhanceCommand}
+								method="POST"
+								action="?/removeUsage"
+								onsubmit={(event) =>
+									!confirm('Piece aus dieser Sendung entfernen?') && event.preventDefault()}
+							>
 								<input type="hidden" name="revision" value={data.show.revision} /><input
 									type="hidden"
 									name="usageId"
@@ -808,9 +841,17 @@
 								/><button
 									class="text-button danger-text"
 									type="submit"
-									aria-label={`${usage.title} aus Reserve entfernen`}>Entfernen</button
+									aria-label={`${usage.title} aus Sendung entfernen`}>Aus Sendung entfernen</button
 								>
 							</form>
+							<UsageEditorDialog
+								{usage}
+								revision={data.show.revision}
+								sectionId=""
+								sections={data.show.sections}
+								error={form?.error}
+								{enhanceCommand}
+							/>
 						</div>
 					</div>
 				{/each}
@@ -869,4 +910,14 @@
 			value={draggedPieceId}
 		/><input type="hidden" name="sectionId" value={dropSectionId} />
 	</form>
+	<form
+		bind:this={removeUsageForm}
+		use:enhance={enhanceCommand}
+		method="POST"
+		action="?/removeUsage"
+		class="hidden-command-form"
+	>
+		<input type="hidden" name="revision" value={data.show.revision} />
+		<input type="hidden" name="usageId" value={removedUsageId} />
+	</form>
 </div>

src/routes/verwaltung/+page.server.ts

@@ -4,9 +4,11 @@ import {
 	createTaxonomy,
 	deleteTaxonomy,
 	getTaxonomy,
+	updateTaxonomy,
 	type TaxonomyKind
 } from '#lib/server/content.js';
 import { getMailConfig } from '#lib/server/config.js';
+import { createTool, listTools, updateTool, type ToolInput } from '#lib/server/tools.js';
 import {
 	inviteUser,
 	isRole,
@@ -25,6 +27,7 @@ export const load: PageServerLoad = ({ locals }) => {
 		taxonomy: getTaxonomy(),
 		users: listUsers(),
 		invitations: listOpenInvitations(),
+		tools: listTools(true),
 		mailTransport: getMailConfig().transport
 	};
 };
@@ -40,9 +43,27 @@ function actionError(cause: unknown): string {
 		return 'Verwendete oder für Vorlagen benötigte Einträge können nicht entfernt werden.';
 	if (code === 'INVALID_COLOR') return 'Bitte eine gültige Farbe wählen.';
 	if (code === 'INVALID_TAXONOMY') return 'Bitte einen gültigen Namen eingeben.';
+	if (code === 'INVALID_ICON') return 'Bitte ein Icon aus der angebotenen Auswahl verwenden.';
+	if (code === 'TOOL_EXISTS') return 'Ein Werkzeug mit diesem Namen existiert bereits.';
+	if (code === 'INVALID_TOOL_URL')
+		return 'Die Start-URL muss eine vollständige HTTP- oder HTTPS-Adresse sein.';
+	if (code === 'INVALID_TOOL_FORMAT')
+		return 'Mindestens ein gewähltes Format existiert nicht mehr.';
+	if (code === 'INVALID_TOOL') return 'Bitte die Werkzeugdaten prüfen.';
 	return 'Die Aktion konnte nicht ausgeführt werden.';
 }
 
+function toolInput(data: FormData): ToolInput {
+	return {
+		name: String(data.get('name') || ''),
+		startUrl: String(data.get('startUrl') || ''),
+		description: String(data.get('description') || ''),
+		iconName: String(data.get('iconName') || ''),
+		isActive: data.get('isActive') === '1',
+		formatIds: data.getAll('formatIds').map(String)
+	};
+}
+
 export const actions = {
 	invite: async ({ locals, request }) => {
 		const actor = requireBarkeeper(locals.user);
@@ -112,12 +133,36 @@ export const actions = {
 			return fail(400, { intent: 'taxonomy', error: 'Ungültige Taxonomieart.' });
 		}
 		try {
-			createTaxonomy(kind, String(data.get('name') || ''), String(data.get('color') || ''));
+			createTaxonomy(
+				kind,
+				String(data.get('name') || ''),
+				String(data.get('color') || ''),
+				String(data.get('iconName') || '')
+			);
 			return { intent: 'taxonomy', success: 'Eintrag angelegt.' };
 		} catch (cause) {
 			return fail(400, { intent: 'taxonomy', error: actionError(cause) });
 		}
 	},
+	updateTaxonomy: async ({ locals, request }) => {
+		requireBarkeeper(locals.user);
+		const data = await request.formData();
+		const kind = String(data.get('kind') || '') as TaxonomyKind;
+		if (!['category', 'format', 'topic'].includes(kind)) {
+			return fail(400, { intent: 'taxonomy', error: 'Ungültige Taxonomieart.' });
+		}
+		try {
+			updateTaxonomy(
+				kind,
+				String(data.get('taxonomyId') || ''),
+				String(data.get('name') || ''),
+				String(data.get('iconName') || '')
+			);
+			return { intent: 'taxonomy', success: 'Eintrag aktualisiert.' };
+		} catch (cause) {
+			return fail(400, { intent: 'taxonomy', error: actionError(cause) });
+		}
+	},
 	deleteTaxonomy: async ({ locals, request }) => {
 		requireBarkeeper(locals.user);
 		const data = await request.formData();
@@ -131,5 +176,25 @@ export const actions = {
 		} catch (cause) {
 			return fail(400, { intent: 'taxonomy', error: actionError(cause) });
 		}
+	},
+	createTool: async ({ locals, request }) => {
+		requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			createTool(toolInput(data));
+			return { intent: 'tool', success: 'Werkzeug angelegt.' };
+		} catch (cause) {
+			return fail(400, { intent: 'tool', error: actionError(cause) });
+		}
+	},
+	updateTool: async ({ locals, request }) => {
+		requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			updateTool(String(data.get('toolId') || ''), toolInput(data));
+			return { intent: 'tool', success: 'Werkzeug aktualisiert.' };
+		} catch (cause) {
+			return fail(400, { intent: 'tool', error: actionError(cause) });
+		}
 	}
 } satisfies Actions;

src/routes/verwaltung/+page.svelte

@@ -1,6 +1,10 @@
 <script lang="ts">
+	import AppIcon from '#lib/components/AppIcon.svelte';
+	import IconPicker from '#lib/components/IconPicker.svelte';
+	import ToolEditorDialog from '#lib/components/ToolEditorDialog.svelte';
 	import type { PageProps } from './$types';
 	let { data, form }: PageProps = $props();
+	let toolDialog: { showModal: (tool?: (typeof data.tools)[number] | null) => void };
 
 	function confirmTaxonomyRemoval(event: SubmitEvent) {
 		if (!confirm('Eintrag wirklich entfernen?')) event.preventDefault();
@@ -12,7 +16,7 @@
 <div class="page-wrap narrow-page">
 	<header class="page-heading">
 		<h1>Verwaltung</h1>
-		<p class="page-intro">Konten, Rollen und bestehende Taxonomie verwalten.</p>
+		<p class="page-intro">Konten, Werkzeuge und bestehende Taxonomie verwalten.</p>
 	</header>
 	{#if form?.error}<div class="form-message error" role="alert">{form.error}</div>{/if}
 	{#if form?.success}<div class="form-message success" role="status">{form.success}</div>{/if}
@@ -113,6 +117,46 @@
 		</section>
 	</div>
 
+	<h2 class="section-heading">Werkzeuge</h2>
+	<section class="quiet-panel tool-management">
+		<div class="panel-heading">
+			<div>
+				<p class="eyebrow">Redaktionelle Hilfsmittel</p>
+				<h2>Werkzeugkatalog</h2>
+			</div>
+			<button class="compact-add-button" type="button" onclick={() => toolDialog.showModal()}>
+				<AppIcon name="plus" /> Werkzeug hinzufügen
+			</button>
+		</div>
+		<p class="catalog-note">
+			Deaktivierte Werkzeuge bleiben in bestehenden Pieces und Sendungen erhalten.
+		</p>
+		<div class="catalog-settings-list tool-settings-list">
+			{#each data.tools as tool (tool.id)}
+				<button
+					type="button"
+					class:inactive={!tool.isActive}
+					aria-label={`${tool.name} bearbeiten`}
+					onclick={() => toolDialog.showModal(tool)}
+				>
+					<span class="catalog-entry-icon"><AppIcon name={tool.iconName || 'wrench'} /></span>
+					<span class="catalog-entry-copy">
+						<strong>{tool.name}</strong>
+						<small
+							>{tool.isActive ? 'Aktiv' : 'Deaktiviert'}{#if tool.formatIds.length}
+								· {data.taxonomy.formats
+									.filter((format) => tool.formatIds.includes(format.id))
+									.map((format) => format.name)
+									.join(', ')}{/if}</small
+						>
+					</span>
+					<AppIcon name="pen" />
+				</button>
+			{/each}
+		</div>
+	</section>
+	<ToolEditorDialog bind:this={toolDialog} formats={data.taxonomy.formats} />
+
 	<h2 class="section-heading">Taxonomie</h2>
 	<div class="settings-grid">
 		<section class="quiet-panel taxonomy-panel">
@@ -126,7 +170,9 @@
 								type="hidden"
 								name="taxonomyId"
 								value={category.id}
-							/><button type="submit" aria-label={`${category.name} entfernen`}>×</button>
+							/><button type="submit" aria-label={`${category.name} entfernen`}
+								><AppIcon name="trash" /></button
+							>
 						</form></span
 					>{/each}
 			</div>
@@ -158,7 +204,9 @@
 								type="hidden"
 								name="taxonomyId"
 								value={format.id}
-							/><button type="submit" aria-label={`${format.name} entfernen`}>×</button>
+							/><button type="submit" aria-label={`${format.name} entfernen`}
+								><AppIcon name="trash" /></button
+							>
 						</form></span
 					>{/each}
 			</div>
@@ -173,20 +221,31 @@
 				><button class="text-button" type="submit">Hinzufügen</button>
 			</form>
 		</section>
-		<section class="quiet-panel taxonomy-panel">
+		<section class="quiet-panel taxonomy-panel topic-management-panel">
 			<p class="eyebrow">Themen</p>
 			<h2>Inhaltliche Zuordnung</h2>
-			<div class="taxonomy-list editable-taxonomy">
+			<div class="topic-settings-list">
-				{#each data.taxonomy.topics as topic (topic.id)}<span
+				{#each data.taxonomy.topics as topic (topic.id)}
-						>{topic.name}
+					<details>
+						<summary
+							><AppIcon name={topic.iconName || 'circle'} /><strong>{topic.name}</strong><AppIcon
+								name="pen"
+							/></summary
+						>
+						<form class="topic-edit-form" method="POST" action="?/updateTaxonomy">
+							<input type="hidden" name="kind" value="topic" />
+							<input type="hidden" name="taxonomyId" value={topic.id} />
+							<label>Name<input name="name" required maxlength="80" value={topic.name} /></label>
+							<IconPicker name={topic.iconName} />
+							<button class="secondary-button" type="submit">Änderungen speichern</button>
+						</form>
 						<form method="POST" action="?/deleteTaxonomy" onsubmit={confirmTaxonomyRemoval}>
-							<input type="hidden" name="kind" value="topic" /><input
+							<input type="hidden" name="kind" value="topic" />
-								type="hidden"
+							<input type="hidden" name="taxonomyId" value={topic.id} />
-								name="taxonomyId"
+							<button class="text-button danger-text" type="submit">Thema löschen</button>
-								value={topic.id}
+						</form>
-							/><button type="submit" aria-label={`${topic.name} entfernen`}>×</button>
+					</details>
-						</form></span
+				{/each}
-					>{/each}
 			</div>
 			<form class="taxonomy-form" method="POST" action="?/createTaxonomy">
 				<input type="hidden" name="kind" value="topic" /><label
@@ -196,7 +255,7 @@
 						maxlength="80"
 						placeholder="Neues Thema"
 					/></label
-				><button class="text-button" type="submit">Hinzufügen</button>
+				><IconPicker name="" /><button class="text-button" type="submit">Hinzufügen</button>
 			</form>
 		</section>
 	</div>