Release 1.32.1

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Close the collapsible menu after choosing a link
2026-10-12 16:50:23 +02:00 · 2026-10-12 16:50:23 +02:00 · 2026-10-12 16:32:24 +02:00 · 2026-10-12 16:31:07 +02:00 · 2026-10-12 16:31:06 +02:00 · 2026-10-12 16:07:28 +02:00
66 changed files with 2832 additions and 294 deletions
@@ -0,0 +1,24 @@
+# Schutz fuer den Fall, dass die Domain auf den Projektordner zeigt statt auf public/ (ADR 116).
+#
+# Bewusst kein "alles sperren": Apache wendet diese Datei auch auf public/ an, und dort soll alles
+# wie gewohnt laufen. Gesperrt werden nur Dateien, die es in public/ nicht gibt oder die
+# public/.htaccess ohnehin sperrt. Die Ordner var/, vendor/, config/, src/ usw. tragen eine eigene
+# Sperrdatei.
+<FilesMatch "^\.|\.(env|db|sqlite|sqlite3|lock|md|yaml|yml|dist|log|key)$">
+    <IfModule mod_authz_core.c>
+        Require all denied
+    </IfModule>
+    <IfModule !mod_authz_core.c>
+        Order deny,allow
+        Deny from all
+    </IfModule>
+</FilesMatch>
+<FilesMatch "^(composer\.json|VERSION|cli-config\.php|migrations\.php)$">
+    <IfModule mod_authz_core.c>
+        Require all denied
+    </IfModule>
+    <IfModule !mod_authz_core.c>
+        Order deny,allow
+        Deny from all
+    </IfModule>
+</FilesMatch>
@@ -186,7 +186,9 @@ Danach `http://127.0.0.1:8080/` öffnen. Der Routerskript-Parameter ist nicht op

 `bin/setup.php` erzeugt ein zufälliges Secret und `var/`. Die Konfiguration steht ausschließlich in der nicht versionierten `.env`; vorhandene Einstellungen und Secrets bleiben erhalten. Die Datenbank liegt in `var/cms.db`. Wiederholtes Seeding erhält existierende Seiten einschließlich ihrer Bearbeitungen. Standardzugangsdaten gibt es nicht.

-**Installation ohne Konsole** läuft über `/install`: Systemprüfung, Datenbank, Migration, Website, erstes Konto. Der Installer antwortet nur, solange keine Installation existiert – sobald ein Konto angelegt ist, liefert jede Adresse darunter 404, und die Sperre hängt am Zustand der Datenbank, nicht an einer Datei. Solange nichts installiert ist, führt jede Adresse dorthin. Davor genügt eine einzelne hochgeladene Datei: `install.php` aus einem Release lädt das Archiv von einer fest eingetragenen Adresse, vergleicht die SHA-256, entpackt es und löscht sich selbst. Ohne passende Prüfsumme wird nichts entpackt. Editor-Endpunkte benötigen Anmeldung, Berechtigung und bei POST einen CSRF-Token.
+**Installation ohne Konsole** läuft über `/install`: Systemprüfung, Datenbank, Migration, Website, erstes Konto. Der Installer antwortet nur, solange keine Installation existiert – sobald ein Konto angelegt ist, liefert jede Adresse darunter 404, und die Sperre hängt am Zustand der Datenbank, nicht an einer Datei. Solange nichts installiert ist, führt jede Adresse dorthin. Davor genügt eine einzelne hochgeladene Datei: `install.php` aus einem Release lädt das Archiv von einer fest eingetragenen Adresse, vergleicht die SHA-256, entpackt es und löscht sich selbst. Ohne passende Prüfsumme wird nichts entpackt. **Seit 1.30.0 öffnet sich der Installer nur mit dem Installationsschlüssel** (ADR 116): `install.php` legt ihn an und zeigt ihn mit einem fertigen Verweis auf seiner Abschlussseite; wer per FTP entpackt, findet ihn in `var/install.key`. Mit dem ersten Konto wird er gelöscht. Das Paket bringt Sperrdateien mit (`.htaccess` im Projektstamm und in `bin/`, `config/`, `migrations/`, `plugins/`, `src/`, `templates/`, `vendor/`; `var/.htaccess` legt die Website selbst an), damit auch bei einer Domain, die versehentlich auf den Projektordner zeigt, weder `.env` noch Datenbank oder Protokolle abrufbar sind. Editor-Endpunkte benötigen Anmeldung, Berechtigung und bei POST einen CSRF-Token.
+
+**Inhalte zwischen Installationen übertragen** (seit 1.32.0, ADR 118): System → „Inhalte übertragen“ exportiert ein Inhaltspaket (Zip) und importiert eines – per Upload oder aus `var/pakete/`. Ersetzt werden Seiten, Bereiche, Menüs, Medien, Formulare, Weiterleitungen, Kategorien, Übersetzungen, Gestaltung und Einstellungen; Anfragen, Statistik und Turnstile-Zugangsdaten bleiben, Konten nur mit eigenem Häkchen. Vorher wird gesichert. Auf der Konsole: `php bin/console cms:paket:export` und `php bin/console cms:paket:import <datei>`.

 ## Eigene 404-Seite (ab 1.8.0)

@@ -397,7 +399,7 @@ Die Seite „Kantarci Markt – Neueröffnung“ (Wilhelm-Drapp-Straße, Baden-B

 ### Neunte lokale Referenzwebsite: Hüfner Gartenbau

-Die Website der Garten- und Landschaftsbau Hüfner GmbH (Iffezheim) liegt in `var/huefner.db` mit Medien in `var/huefner-media`; die Startkonfiguration `huefner` in `.claude/launch.json` nutzt Port 8102, `huefner-prod` denselben Bestand im Produktionsmodus auf Port 8103 zum Messen. `sh scripts/reset-huefner.sh [Entwurfsordner]` kopiert die Fotos aus dem gelieferten Entwurf nach `var/huefner-assets` und schneidet den Baum aus dem Logo als Seitensymbol (`scripts/build-huefner-assets.php`; ohne Argument nimmt es die schon vorbereiteten Bilder), wirft die Installation weg, baut mit `scripts/seed-huefner.php` Gestaltung, Kopf- und Fußbereich, Startseite, Impressum, Datenschutz, 404, Menü, Einstellungen und das Formular `anfrage` auf und holt Barlow und Barlow Condensed auf den eigenen Server. Gemessen mit `MSYS_NO_PATHCONV=1 CMS_URL=http://127.0.0.1:8103 CMS_PATHS=/,/impressum,/datenschutz npm run audit`. Die bewussten Abweichungen vom Entwurf stehen im Kopf des Skripts.
+Die Website der Garten- und Landschaftsbau Hüfner GmbH (Iffezheim) liegt in `var/huefner.db` mit Medien in `var/huefner-media`; die Startkonfiguration `huefner` in `.claude/launch.json` nutzt Port 8102, `huefner-prod` denselben Bestand im Produktionsmodus auf Port 8103 zum Messen. `sh scripts/reset-huefner.sh [Entwurfsordner Unterlagenordner]` kopiert die Fotos aus dem gelieferten Entwurf und Umuts Unterlagen (Alpaka-Fotos, PQ-Logo, Galabau-Signet, PQ-Bescheinigung und Freistellungsbescheinigungen als PDF, unter festen Namen) nach `var/huefner-assets` und schneidet den Baum aus dem Logo als Seitensymbol (`scripts/build-huefner-assets.php`; ohne Argumente nimmt es die schon vorbereiteten Dateien), wirft die Installation weg, baut mit `scripts/seed-huefner.php` Gestaltung, Kopf- und Fußbereich, Startseite, Alpakaseite, Impressum, Datenschutz, 404, Menü, Einstellungen und das Formular `anfrage` auf und holt Barlow und Barlow Condensed auf den eigenen Server und schreibt zuletzt das Inhaltspaket `var/huefner-paket.zip` für die Live-Seite (dort unter System importieren, Konten bleiben). Gemessen mit `MSYS_NO_PATHCONV=1 CMS_URL=http://127.0.0.1:8103 CMS_PATHS=/,/alpakas CMS_AUDIT_DIR=reports/lighthouse-huefner-termin node scripts/audit.mjs`. Die Startseite liegt knapp unter dem HTML-Budget von 150 KB aus `test:browser`: wiederkehrende Bausteine tragen ihre Gestaltung deshalb am Behälter. Die bewussten Abweichungen vom Entwurf stehen im Kopf des Skripts.

 Zusätzliche Prüfung mit den lokalen Kant-IT-Inhalten: `node scripts/admin-quality-check.mjs` (PHP über `PHP_BINARY` wählbar). Das Skript benötigt `var/kantit.db` und `var/kantit-media`, erstellt eine eigene Datenbankkopie und ein zufälliges Testkonto darin; es ändert die Pilotdatenbank nicht. Screenshots und Bericht landen in `reports/admin-quality/`.

@@ -1 +1 @@
-1.28.0
+1.32.1
@@ -0,0 +1,9 @@
+# Dieser Ordner gehoert nicht ins Netz (ADR 116). Zeigt die Domain richtig auf public/, wird diese
+# Datei nie gelesen; zeigt sie versehentlich auf den Projektordner, sperrt sie hier alles.
+<IfModule mod_authz_core.c>
+    Require all denied
+</IfModule>
+<IfModule !mod_authz_core.c>
+    Order deny,allow
+    Deny from all
+</IfModule>
@@ -0,0 +1,9 @@
+# Dieser Ordner gehoert nicht ins Netz (ADR 116). Zeigt die Domain richtig auf public/, wird diese
+# Datei nie gelesen; zeigt sie versehentlich auf den Projektordner, sperrt sie hier alles.
+<IfModule mod_authz_core.c>
+    Require all denied
+</IfModule>
+<IfModule !mod_authz_core.c>
+    Order deny,allow
+    Deny from all
+</IfModule>
@@ -0,0 +1,9 @@
+# Dieser Ordner gehoert nicht ins Netz (ADR 116). Zeigt die Domain richtig auf public/, wird diese
+# Datei nie gelesen; zeigt sie versehentlich auf den Projektordner, sperrt sie hier alles.
+<IfModule mod_authz_core.c>
+    Require all denied
+</IfModule>
+<IfModule !mod_authz_core.c>
+    Order deny,allow
+    Deny from all
+</IfModule>
@@ -0,0 +1,24 @@
+# Schutz fuer den Fall, dass die Domain auf den Projektordner zeigt statt auf public/ (ADR 116).
+#
+# Bewusst kein "alles sperren": Apache wendet diese Datei auch auf public/ an, und dort soll alles
+# wie gewohnt laufen. Gesperrt werden nur Dateien, die es in public/ nicht gibt oder die
+# public/.htaccess ohnehin sperrt. Die Ordner var/, vendor/, config/, src/ usw. tragen eine eigene
+# Sperrdatei.
+<FilesMatch "^\.|\.(env|db|sqlite|sqlite3|lock|md|yaml|yml|dist|log|key)$">
+    <IfModule mod_authz_core.c>
+        Require all denied
+    </IfModule>
+    <IfModule !mod_authz_core.c>
+        Order deny,allow
+        Deny from all
+    </IfModule>
+</FilesMatch>
+<FilesMatch "^(composer\.json|VERSION|cli-config\.php|migrations\.php)$">
+    <IfModule mod_authz_core.c>
+        Require all denied
+    </IfModule>
+    <IfModule !mod_authz_core.c>
+        Order deny,allow
+        Deny from all
+    </IfModule>
+</FilesMatch>
@@ -118,6 +118,10 @@ services:
            $root: '%kernel.project_dir%'
            $databaseUrl: '%env(projectdir:DATABASE_URL)%'
            $mediaDirectory: '%env(projectdir:MEDIA_DIRECTORY)%'
+    App\Ops\SitePackage:
+        arguments:
+            $root: '%kernel.project_dir%'
+            $mediaDirectory: '%env(projectdir:MEDIA_DIRECTORY)%'
    # Der Aufgabenplan. Die Aufgaben kommen ueber ihr Etikett herein, damit diese Stelle nicht
    # jedes Mal mitwaechst.
    App\Ops\Scheduler:
@@ -1,6 +1,76 @@
 # Architekturentscheidungen

-Stand: 09.10.2026. Arbeitstitel KantSites; Produktname offen.
+Stand: 12.10.2026. Arbeitstitel KantSites; Produktname offen.
+
+## ADR 119 – Das Menü schließt nach einer Wahl (12.10.2026)
+
+Anlass: Umut: „Wenn man Links zu Ankern, also #kontakt, im Menü klickt, dann schließt sich das Menü nicht beim Mobilmenü. Also immer schließen, wenn man ausgewählt hat, egal was.“
+
+**Ursache.** Das aufklappbare Menü ist ein `details` (ADR 117: öffnet ohne Skript). Ein Sprungziel auf derselben Seite lädt nicht neu, also bleibt `details` offen und liegt über dem Ziel. CSS kann ein `details` bei einem Linkklick nicht schließen.
+
+**Entscheidung.** `scrolled.js`, das kleine Skript des Kopfbereichs, schließt das Menü beim Klick auf einen Link darin (`initMenus`). Es kommt nur dorthin, wo es gebraucht wird: wenn ein aufklappbares Menü (Burger oder waagerecht mit Zusammenklappen) einen Link auf ein Sprungziel **dieser** Seite trägt (`#…` oder der eigene Pfad mit `#…`). Ein Link auf eine andere Seite braucht nichts: Die Seite lädt neu, und weil öffentliche Seiten `no-store` senden, stellt „Zurück“ kein offenes Menü aus dem Seiten-Cache her (im Browser geprüft). So bleibt jede Seite ohne solche Sprünge bei `script-src 'none'`, und auf Seiten, die `scrolled.js` ohnehin laden (Nach-oben-Knopf, Kopf mit Scrollfarben), kommt kein Skript dazu.
+
+**Geprüft:** Im Browser auf Hüfner (iPhone): „Kontakt“, „Angebot anfragen“ und „Leistungen“ schließen das Menü und springen; „Alpakas“ und „Zurück“ zeigen es geschlossen. Die bestehenden Tests, die `script-src 'none'` auf Seiten mit aufklappbarem Menü ohne Sprungziele verlangen, bleiben unverändert grün.
+
+## ADR 118 – Inhaltspakete: Export und Import ohne die Konten (12.10.2026)
+
+Anlass: Umut: „Können wir sowas wie einen Importer einbauen, weil sich nach jeder Anpassung sonst das Passwort ändert? Wo man auswählen muss, ob Passwort/Benutzer überschrieben werden sollen. Gerne auch als Plugin.“ Bisher wurde eine lokal gebaute Website als ganze SQLite-Datei hochgeladen – samt Konten (neues Passwort nach jedem Neuaufbau) und ohne das, was nur live entstanden war (Anfragen, Statistik).
+
+**Entscheidung: im Kern, nicht als Plugin.** Plugins führen bewusst keinen eigenen Servercode aus (ADR zum Pluginsystem; serverseitiger Code nur mit Isolation). Ein Import schreibt Datenbank und Medienordner – das gehört in den Kern, unter System, nur für Administratoren.
+
+**Paket.** Zip mit `paket.json` (Art, Format 1, Fassung, Website, Konten ja/nein, Zahlen, SHA-256 von `inhalt.json`), `inhalt.json` (Zeilen je Tabelle) und `medien/` (Bildvarianten, PDFs, erzeugte Seitensymbole). JSON statt SQLite-Datei: Ein Paket geht von SQLite nach MySQL und zurück, und jede Zeile wird vor dem Schreiben geprüft. Inhalt: `page`, `revision`, `partial`, `menu`, `media`, `document`, `form`, `redirect`, `term`, `page_term`, `page_translation` und die Website (Name, Sprache, Gestaltung, Einstellungen). **Nicht** darin: Anfragen, Statistik, Aufgaben, Plugin-Stand, Migrationsliste und die Zugangsdaten zu Diensten (`turnstile`, `turnstileSiteKey`, `turnstileSecret`). Konten nur mit „Konten mitnehmen“ beim Export.
+
+**Import (`App\Ops\SitePackage::import`).** Prüfen vor Schreiben: nur bekannte Einträge im Zip (keine Pfade nach oben, keine anderen Dateitypen, Größengrenzen gegen Zip-Bomben), Prüfsumme von `inhalt.json`, nur bekannte Tabellen und Spaltennamen, jedes Seiten- und Bereichsdokument durch `DocumentValidator`, Paket nicht aus einer neueren Fassung. Dann Sicherung (`vor Import`), Wartungszustand, Inhalte in einer Transaktion ersetzen (nur Spalten, die es hier gibt – ein älteres Paket passt so in ein neueres Schema), Website-Einstellungen übernehmen außer den Dienst-Zugangsdaten, Anfragen über die Formularadresse dem neuen Formular zuordnen, Medienordner ersetzen. **Konten nur mit eigenem Häkchen** („Konten und Passwörter aus dem Paket übernehmen“); ohne bleiben Benutzer und Passwörter der Website. Ein Häkchen bei einem Paket ohne Konten bricht ab, ohne etwas zu ändern.
+
+**Oberfläche.** System → „Inhalte übertragen“: Export als Download (Datei wird nach dem Senden gelöscht), Import per Upload oder aus `var/pakete/` (für Pakete über der Upload-Grenze des Hostings, die angezeigt wird), Bestätigungshäkchen, Ergebnisseite mit den Schritten und einem Hinweis, falls Schriften der neuen Gestaltung auf dem Server fehlen. Konsole: `cms:paket:export [--mit-benutzern] [--ziel=…]`, `cms:paket:import <datei> [--mit-benutzern] [--ja]`.
+
+**Folgen.** Das Zurückspielen einer Sicherung bleibt Konsolensache; der Import ist der Weg für Inhalte aus einer anderen Installation, mit eigener Sicherung davor. Reset-Skripte können ein Paket schreiben (zuerst `reset-huefner.sh` → `var/huefner-paket.zip`). Keine Migration.
+
+## ADR 117 – Menü schließt beim Klick daneben, Netzwerk-Symbole, schlankere Symbole (12.10.2026)
+
+Anlass: Umut: „Bei Mobilmenü, wenn es aufgeklappt ist, schließt es nicht, wenn man irgendwo anders hinklickt.“ Und für Hüfner: Facebook, Instagram und „Angebot anfragen“ als Menü-Buttons statt eigener Knöpfe im Kopf.
+
+**Entscheidungen.**
+1. **Klick daneben schließt – ohne Skript.** Das Menü bleibt ein `details` (es soll auf jeder Seite ohne Skript aufgehen). Solange es offen ist, legt `summary::before` eine unsichtbare, feste Fläche über die Seite (`z-index:29`); sie gehört zum Knopf, ein Klick darauf schließt also. Die Menüfläche liegt darüber (`z-index:30`; außerhalb des Kopfbereichs per `:where()` mit niedriger Spezifität, damit die Platzierung im Kopf gewinnt). Der erste Klick daneben schließt nur und löst nichts darunter aus – wie bei jedem aufgeklappten Menü. Escape schließt weiterhin nicht (das bräuchte ein Skript). Grenze: Hat ein Vorfahr des Menüs `transform`/`filter`, deckt die feste Fläche nur diesen Vorfahren ab.
+2. **Facebook, Instagram, WhatsApp im Symbolsatz.** Dieselben Strichformen wie `social-icon.html.twig`, als Pfad in `icon.html.twig`, `icons.js` (Reiter „Soziale Netzwerke“) und `DocumentValidator::ICONS`. Damit sind sie an Menü-Buttons, Buttons, Symbolkarten und Symbolen wählbar. Keine Schemaänderung; ein Dokument mit diesen Symbolen braucht aber einen Kern ab 1.31.0.
+3. **Strichattribute ins Stylesheet.** Jedes Symbol trug `fill`, `stroke`, `stroke-width`, `stroke-linecap` und `stroke-linejoin` als Attribute, rund 105 Zeichen, bei etwa 40 Symbolen je Seite gut 4 KB HTML. Jetzt steht das einmal als `svg.block-icon{…}` in `site.css` und `admin.css`; `width`/`height` bleiben am Element, damit nichts ohne Stylesheet riesig wird. Anlass war die Hüfner-Startseite, die mit den Menü-Buttons das HTML-Budget von 150 KB riss.
+
+**Geprüft:** Eigene Browserprüfung auf iPad (quer) und iPhone: Menü öffnet, Menülinks liegen über der Fläche, Klick daneben schließt, kein waagerechtes Scrollen. `test:menu-buttons` (Menü-Buttons, axe), `test:editor` (Verwaltung mit Symbolen, axe), `npm test` (Symbolsatz in Twig, JS und Validator gleich). `test:responsive-navigation` scheitert im Editorteil am Klick auf den Strukturbaum – ebenso ohne diese Änderungen (Gegenprobe mit zurückgesetzten Dateien), also vorbestehend.
+
+## ADR 116 – Härtung nach dem Sicherheitscheck (12.10.2026)
+
+Anlass: Umut: „Kannst du mal einen Sicherheitscheck für KantSites machen? Das Ding muss bombensicher sein.“ Fünf getrennte Prüfungen (Anmeldung/Rollen, öffentliche Eingaben, XSS/Ausgabe, Uploads/Dateien, Installer/Updater/Betrieb) plus ein Blick von außen auf die Live-Seiten. Keine ausnutzbare Lücke ohne Anmeldung bei korrekt eingerichteter Installation; behoben wird, was übrig blieb.
+
+**Entscheidungen.**
+1. **Installationsschlüssel.** Der Installer war bis zum ersten Konto für jeden offen – wer eine frisch entpackte Installation zuerst aufrief, konnte sie übernehmen (und vorher über den MySQL-Host fremde Rechner abtasten). Jetzt öffnet sich kein Schritt ohne einen 128-Bit-Schlüssel in `var/install.key`. `install.php` legt ihn an und zeigt ihn nur auf seiner Abschlussseite mit fertigem Verweis (`/install/schluessel?schluessel=…`); wer per FTP entpackt, liest die Datei. Im Browser bleibt ein Cookie `kant_install` mit einem HMAC über den Schlüssel (HttpOnly, SameSite=Strict, Pfad `/install`), nie der Schlüssel selbst. Mit dem ersten Konto wird die Datei gelöscht; das Anlegen des ersten Kontos läuft in einer Transaktion. Restrisiko: Wer `install.php` vor dem Betreiber aufruft, sieht den Schlüssel – das Fenster ist die Zeit zwischen Hochladen und Aufrufen.
+2. **Sperrdateien.** Zeigte die Domain auf den Projektordner statt auf `public/`, waren `.env`, Datenbank, Sicherungen und Protokolle abrufbar; die Sperren standen nur in `public/.htaccess`. Jetzt sperren `.htaccess`-Dateien `bin/`, `config/`, `migrations/`, `plugins/`, `src/`, `templates/`, `vendor/` (Buildskript) und `var/` (legt die Website selbst an, `App\Ops\Protection`), dazu im Projektstamm gezielt Dotfiles, `env|db|sqlite|lock|md|yaml|yml|dist|log|key` und `composer.json`, `VERSION`, `cli-config.php`, `migrations.php`. Bewusst **kein** pauschales „alles sperren“ im Projektstamm: Apache wendet die Datei auch auf `public/` an, ein Update hätte jede Seite mit 403 lahmlegen können. Eine eigene `.htaccess` des Betreibers im Projektstamm bleibt unberührt; fehlende Dateien trägt die Website beim ersten Aufruf nach (auch nach einem Update von einer Fassung, deren Updater sie nicht kannte). Vorlagen: `config/schutz/`.
+3. **Sektionen nach ihrem eigenen Schema-Stand.** Eine verknüpfte Sektion wurde mit den Ausgabeflags der Seite gerendert. Eine Sektion mit Schema unter v12 (deren Text nicht gefiltert wird) gab so in einer neueren Seite ungefiltertes HTML aus – ein Publisher konnte `<meta refresh>` oder fremde Links setzen, was sonst nur der Admin darf. Jetzt rechnet die Vorlage mit `section.schemaVersion`; neue Sektionen beginnen im aktuellen Schema.
+4. **Redakteure ändern nichts Veröffentlichtes.** Adresse verschieben, Papierkorb (jeweils samt Unterseiten), Kopf/Fuß wählen und Beitragsdaten (robots, SEO-Titel, Datum …) wirkten sofort öffentlich und brauchten nur ROLE_EDITOR. Jetzt verlangen sie ROLE_PUBLISHER, sobald die Seite (bzw. eine Unterseite) veröffentlicht ist; Entwürfe bleiben frei.
+5. **Geplante Veröffentlichung mit fester Fassung.** Zum Termin ging der neueste Entwurf online, auch einer, den ein Redakteur nach dem Planen gespeichert hatte. Jetzt speichert `schedule()` die damalige Fassung in `page.publish_revision_id` (Migration `20261012000100`, eine Spalte); `publishDue()` veröffentlicht genau sie. Planungen ohne Fassung (aus älteren Versionen) veröffentlichen weiterhin den Entwurf.
+6. **Formulare.** Das Zeitsiegel ist an das Formular und den Zweck gebunden (`FormRepository::stamp`). Die Grenze je Absender zählt bei IPv6 das /64-Netz. Neu: höchstens 30 gespeicherte Anfragen je Formular und 120 insgesamt je Stunde; darüber wird nichts gespeichert und nichts verschickt – sichtbar mit Hinweis aufs Telefon statt still, damit kein echter Besucher glaubt, seine Anfrage sei angekommen.
+7. **Kleinere Härtungen.** Einwilligungs-Rücksprung ohne Steuerzeichen und Backslash (Tabulator machte aus `/<Tab>/fremd` eine offene Weiterleitung). Update-Ziel nur in der Form `1.2.3` bzw. `v1.2.3`, `git checkout` mit `--`. Eigenes CSS: keine Geschwister des Blocks selbst (`& ~`, `& +`), Anführungszeichen paarweise, keine Kommentarzeichen in Werten; bereits gespeichertes CSS, das das verletzt, entfällt beim Ausgeben still, statt die Seite zu brechen.
+
+**Nicht umgesetzt, mit Grund.** Signierte Releases (Umut: später); dann gehört ein Offline-Schlüssel dazu. Antwortzeit beim Login für unbekannte Benutzer, Trusted Proxies, Turnstile-Hostname, `%PDF-` ab Byte 0, archivierte PDFs, Statistik-Obergrenzen, MySQL-Passwort in der Prozessliste: niedrig, offen in STATUS.
+
+**Folgen.** Neuinstallationen brauchen den Schlüssel; die Doku sagt, wo er steht. Bestehende Installationen merken nur die Sperrdateien (keine Wirkung bei korrekter Einrichtung) und die engeren Rollen. Migration läuft mit dem Updater. Ausgeliefert mit 1.30.0.
+
+## ADR 115 – Einwilligung ohne Neuladen (12.10.2026)
+
+Anlass: Umut auf der Hüfner-Seite: „dieses Einwilligen, da lädt die Seite komplett neu. Bekommen wir das auch ohne hin?“ Hinweis und Knopf am eingebetteten Inhalt waren reine Formulare (ADR zur Einwilligung: kein Skript), der Server setzte das Cookie und leitete zurück.
+
+**Entscheidung.** Das Formular bleibt der Weg, ein kleines Skript `public/assets/consent.js` verbessert ihn. Es schickt dasselbe Formular im Hintergrund an `/einwilligung` mit der Kopfzeile `X-Kant-Consent: 1`; der Server antwortet dann mit 204 und dem Cookie statt mit der Weiterleitung (Herkunftsprüfung unverändert). Wurde etwas erlaubt, holt das Skript die Seite noch einmal und übernimmt daraus nur die eingebetteten Inhalte und die Zeile „Rechtliches“ (dort steht jetzt „Einwilligung ändern“); dann verschwindet der Hinweis. Der Fokus geht an den eingesetzten Rahmen bzw. an `#main`. Schlägt etwas fehl, sendet das Skript das Formular normal ab. Die Adresse eines Inhalts steht weiterhin erst nach der Einwilligung im HTML – kein `data-src` im Platzhalter.
+
+**Was sich dafür ändert.** (1) Die Sicherheitsrichtlinie nennt die Hosts aller eingebetteten Inhalte der Seite in `frame-src`, auch solange die Einwilligung fehlt: eine Richtlinie steht beim Laden fest, ein nachträglich eingesetzter Rahmen bräuchte sonst ein Neuladen. Die Erlaubnis lädt nichts. (2) Seiten mit offener Frage (Hinweis offen oder ein Inhalt wartet) senden `script-src 'self'` und laden `consent.js`; nach der Entscheidung ohne wartende Inhalte wieder `script-src 'none'`. (3) Das Skriptbudget von `test:browser` (3 je Seite) zählt `consent.js` nicht mit, weil es nur bis zur Entscheidung da ist.
+
+**Folgen.** Ohne JavaScript bleibt alles wie bisher. Andere Vorlagen als `PageController` (falls sie Einbettungen zeigen) laden das Skript nicht und bleiben beim Neuladen. Ausgeliefert mit 1.29.0.
+
+## ADR 114 – Die Umschreibregel fängt index.php selbst ab (12.10.2026)
+
+Anlass: huefner-gartenbau.de bei IONOS (PHP 8.4.26) antwortete auf `/`, `/install` und `/assets/` mit einem weißen 500er von Apache. Die Notfallschicht (ADR 113) griff nicht, weil PHP gar nicht erreicht wurde. `/index.php/install` lieferte dagegen 200, auch mit der `.htaccess` – die Datei wurde also gelesen, der Fehler lag in der Umschreibregel. Vermutete Ursache: `RewriteCond %{REQUEST_FILENAME} !-f` erkennt dort die bereits umgeschriebene `index.php` nicht als Datei, die Regel greift erneut, Apache bricht nach zehn internen Umleitungen ab.
+
+**Entscheidung.** `public/.htaccess` setzt `RewriteBase /` und beendet die Umschreibung für `index.php` selbst (`RewriteRule ^index\.php$ - [L]`), wie die `.htaccess` von WordPress. Auf dem Hosting von Umut mit beiden Zeilen bestätigt; welche der beiden allein genügt hätte, ist nicht geprüft. `CmsTest` sichert die Zeilen ab.
+
+**Folgen.** `RewriteBase /` setzt voraus, dass die Domain auf `public/` zeigt – das war schon Bedingung, eine Installation in einem Unterordner einer Domain ist nicht vorgesehen. Bestehende Installationen bekommen die Zeilen mit dem nächsten Archivupdate, weil der Updater die `.htaccess` des Releases übernimmt (nur eingeschaltete HTTPS-/HSTS-Zeilen werden erhalten). `Options -Indexes -MultiViews` verträgt IONOS: auf huefner-gartenbau.de wieder eingeschaltet, die Seite lädt weiter. Ausgeliefert mit 1.28.1.

 ## ADR 113 – Kein leerer 500er mehr, Update mit einem Klick nach reiseSoft (09.10.2026)

@@ -1,6 +1,94 @@
 # Projektstatus

-## Notfallseite, Fehlerprotokoll und Update mit einem Klick (09.10.2026, noch nicht veröffentlicht)
+## Fassung 1.32.1: Menü schließt nach einer Wahl (12.10.2026)
+
+**Anlass:** Umut: Ein Link auf ein Sprungziel (#kontakt) im Mobilmenü ließ das Menü offen.
+
+**Änderung (ADR 119):** `scrolled.js` schließt das aufgeklappte Menü beim Klick auf einen Link darin. Geladen wird es zusätzlich nur, wenn ein aufklappbares Menü Sprungziele derselben Seite enthält; Seiten ohne solche Links bleiben ohne Skript (Links auf andere Seiten laden neu, `no-store` verhindert ein offenes Menü nach „Zurück“).
+
+**Geprüft:** PHPUnit 665 Tests grün, `npm test` 41 grün; im Browser auf Hüfner (iPhone): „Kontakt“, „Angebot anfragen“, „Leistungen“ schließen das Menü und springen. Bekannt und vorbestehend: `test:responsive-navigation` scheitert am Klick im Editor-Strukturbaum.
+
+**Live Hüfner (12.10.2026):** Umut hat die Datenbank hochgeladen, ohne Medienordner – Bilder antworteten mit 404 (Kennungen vom letzten Neuaufbau). Lösung: `var/huefner-paket.zip` unter System → „Inhalte übertragen“ importieren; bringt die passenden Medien mit.
+
+## Fassung 1.32.0: Inhaltspakete – Export und Import ohne die Konten (12.10.2026)
+
+**Anlass:** Umut: Nach jedem Hochladen einer neu aufgebauten Datenbank galt live ein anderes Passwort; gewünscht ist ein Importer mit der Wahl, ob Benutzer/Passwort überschrieben werden („gerne auch als Plugin“).
+
+**Neu im Kern (ADR 118):** System → „Inhalte übertragen“: Paket exportieren (Download, Konten nur mit Häkchen) und importieren (Upload oder aus `var/pakete/`, Upload-Grenze des Hostings angezeigt). Ersetzt werden Seiten mit Fassungen, Bereiche, Menüs, Medien/PDFs, Formulare, Weiterleitungen, Kategorien, Übersetzungen, Gestaltung und Einstellungen; Anfragen (neu dem Formular zugeordnet), Statistik, Aufgaben, Plugin-Stand und Turnstile-Zugangsdaten bleiben; Konten nur mit eigenem Häkchen. Vorher Sicherung, währenddessen Wartung, jede Datei und jedes Dokument geprüft. Konsole: `cms:paket:export`, `cms:paket:import`. Im Kern statt als Plugin, weil Plugins keinen Servercode ausführen. `reset-huefner.sh` schreibt zuletzt `var/huefner-paket.zip`.
+
+**Geprüft:** PHPUnit vollständig 665 grün (neu `SitePackageTest`: Import ersetzt Inhalte und behält Konten, Anfragen, Dienst-Zugangsdaten; Konten nur mit beiden Häkchen; neuere Fassung abgelehnt; fünf manipulierte Pakete ändern nichts – fremde Datei mit `../`, Skript als Medium, veränderter Inhalt, fremde Tabelle, ungültiges Dokument). `npm test` 41, `lint:twig`, php-cs-fixer. Durchlauf auf der Konsole: Hüfner exportiert und in eine veränderte Kopie importiert (Passwort, Anfrage, Turnstile blieben, Alpakaseite kam zurück, Medienordner ersetzt). Oberfläche in der lokalen Hüfner-Verwaltung: zu großer Upload mit Hinweis abgelehnt, „Konten übernehmen“ bei Paket ohne Konten abgebrochen, Import aus `var/pakete/` abgeschlossen, danach weiter angemeldet. `test:editor` grün inklusive axe der Systemseite – ein erster Lauf parallel zu PHPUnit scheiterte, der Wiederholungslauf allein bestand.
+
+**Veröffentlicht:** Tag `v1.32.0`, Release-Eintrag mit Archiv (3629 Dateien, 5,3 MB, gebaut aus `var/release-source-1.32.0`), `.sha256` und `install.php`; Prüfsumme nach dem Herunterladen bestätigt. Keine Migration.
+
+**Nächster Schritt:** huefner-gartenbau.de auf 1.32.0 aktualisieren, dann `var/huefner-paket.zip` unter System → „Inhalte übertragen“ importieren (ohne Konten-Häkchen).
+
+## Fassung 1.31.0: Menü schließt beim Klick daneben, Netzwerk-Symbole; Hüfner-Kopf (12.10.2026)
+
+**Anlass:** Umut: aufgeklapptes Mobilmenü schließt nicht beim Klick daneben; bei Hüfner wirkt der Kopf auf dem iPad verloren (Menü-Knopf mittig), und Facebook, Instagram und „Angebot anfragen“ sollen ins Menü.
+
+**Neu im Kern (ADR 117):** Klick neben das aufgeklappte Menü schließt es – reines CSS (unsichtbare Fläche am Menü-Knopf), kein Skript. Facebook, Instagram und WhatsApp im Symbolsatz (Menü-Buttons, Buttons, Symbole). Die Strichattribute der Symbole stehen jetzt als `svg.block-icon` in `site.css`/`admin.css` statt an jedem Symbol (rund 4 KB weniger HTML je Seite).
+
+**Hüfner (nur Inhalt):** Kopf aus Logo und rechtsbündigem Menü; „Angebot anfragen“, Facebook und Instagram als Menü-Buttons. Desktop zeigt in der Zeile nur „Angebot anfragen“ (F/I stehen in der Leiste darüber), im aufgeklappten Menü stehen alle drei, die Symbole nebeneinander. Menü-Knopf auf iPad und Telefon rechts; Abstand und Schrift schrumpfen knapp über 1024 px mit, damit die Zeile nicht umbricht. Upload-Paket neu (`var/huefner-upload.zip`, braucht 1.31.0).
+
+**Geprüft:** PHPUnit vollständig 657 grün; `npm test` 41; `lint:twig`; `test:menu-buttons` und `test:editor` grün inklusive axe; `test:browser` auf Hüfner grün (HTML Startseite rund 148 KB). Eigene Browserprüfung auf iPad quer und iPhone: öffnen, Menülinks bedienbar, Klick daneben schließt, kein waagerechtes Scrollen; Kopf bei 810, 1025, 1080, 1100, 1280 und 1366 px im Bild. **Veröffentlicht:** Tag `v1.31.0`, Release-Eintrag mit Archiv (3624 Dateien, 5,3 MB, gebaut aus `var/release-source-1.31.0`), `.sha256` und `install.php`; Prüfsumme nach dem Herunterladen bestätigt.
+
+**Nächster Schritt:** huefner-gartenbau.de auf 1.31.0 aktualisieren, dann `var/huefner-upload.zip` einspielen (Reihenfolge wichtig: die Datenbank nutzt die neuen Symbole).
+
+**Bekannt:** `test:responsive-navigation` scheitert im Editorteil am Klick auf den Strukturbaum – auch ohne diese Änderungen (Gegenprobe), vorbestehend.
+
+## Fassung 1.30.0: Härtung nach dem Sicherheitscheck (12.10.2026)
+
+**Anlass:** Umut: „Sicherheitscheck für KantSites … das Ding muss bombensicher sein.“ Prüfung in fünf Bereichen plus Blick von außen auf huefner-gartenbau.de und kant-it.de; Ergebnis im Chat vom 12.10.2026, Umsetzung „1.30.0, Signatur später“.
+
+**Behoben (ADR 116):** Installationsschlüssel für den Installer (`var/install.key`, von `install.php` angelegt und angezeigt); Sperrdateien im Projektstamm und in allen internen Ordnern (`var/` legt die Website selbst an); verknüpfte Sektionen nach ihrem eigenen Schema-Stand gerendert (kein ungefiltertes HTML durch alte Sektionen); Redakteure ändern Adresse, Papierkorb, Bereiche und Beitragsdaten veröffentlichter Seiten nicht mehr; geplante Veröffentlichung mit fester Fassung (Migration `20261012000100`); Formular-Siegel je Formular, IPv6 je /64, Obergrenze je Formular und gesamt mit sichtbarem Hinweis; offene Weiterleitung per Tabulator beim Einwilligen; Update-Ziel nur `1.2.3`; eigenes CSS bleibt im Block.
+
+**Geprüft:** PHPUnit vollständig 657 Tests: im Gesamtlauf 656 grün, ein Fehlschlag (`ArchiveUpdateTest`: die neue `.htaccess` im Projektstamm stand weder in der Ersetzungsliste noch in den bewussten Ausnahmen – jetzt als Ausnahme eingetragen, weil sie dem Betreiber gehören kann), danach die betroffenen Dateien (ArchiveUpdate, Cms, Installation, InstallFlow, SingleFileInstaller, Translation; 436 Tests) erneut grün. Neu getestet: Installer nur mit Schlüssel (falscher Schlüssel, gefälschtes Cookie, Verweis aus install.php, Löschen nach dem ersten Konto), Sperrdateien, Sektion mit altem Schema, Redakteur vs. veröffentlichte Seite, geplante Fassung, Formular-Siegel je Formular, IPv6-/64, Flut-Grenze mit Hinweis, Einwilligungs-Rücksprung mit Tabulator/Umbruch/Backslash, CSS-Geschwister/Kommentare. Gegenprobe: der Sektionstest schlägt ohne den Fix an. `npm test` 41, `lint:twig`, php-cs-fixer; `test:browser` auf Hüfner grün; `test:editor` grün inklusive axe; im Browser ein echtes Absenden des Hüfner-Formulars mit neuem Siegel (Testeinsendung danach gelöscht). Hüfner-Upload-Paket mit migrierter Datenbank (`20261012000100`) neu gebaut.
+
+**Veröffentlicht:** Tag `v1.30.0`, Release-Eintrag mit Archiv (5,5 MB, gebaut aus `var/release-source-1.30.0`, enthält alle Sperrdateien inkl. `vendor/.htaccess`), `.sha256` und `install.php` (mit Installationsschlüssel); Prüfsumme nach dem Herunterladen bestätigt. Eine Migration (`20261012000100`), läuft mit dem Updater.
+
+**Nächster Schritt:** Installationen auf 1.30.0 aktualisieren (huefner-gartenbau.de, kant-it.de, weitere); bei Hüfner danach das Upload-Paket einspielen und die HTTPS-Zeilen einschalten.
+
+**Offen (niedrig):** signierte Releases; Login-Antwortzeit für unbekannte Benutzer; Trusted-Proxy-Einstellung für Hosting hinter CDN; Turnstile-Hostname; `%PDF-` ab Byte 0; archivierte PDFs bleiben abrufbar; Statistik ohne Obergrenze für erfundene Verweise; MySQL-Passwort in der Prozessliste bei Sicherungen; Theme-Vorlagen ohne Versionsprüfung. **Live:** huefner-gartenbau.de antwortet auch über `http://` ohne Umleitung und ohne HSTS – die HTTPS-Zeilen in `public/.htaccess` einschalten.
+
+## Fassung 1.29.0: Einwilligung ohne Neuladen (12.10.2026)
+
+**Anlass:** Umut auf der Hüfner-Seite: Beim Einwilligen ins YouTube-Video lädt die Seite komplett neu.
+
+**Neu im Kern (ADR 115):** `public/assets/consent.js` schickt Hinweis und Knopf am eingebetteten Inhalt im Hintergrund ab (`X-Kant-Consent: 1` → 204 mit Cookie statt Weiterleitung), holt die Seite neu und tauscht nur Einbettungen und „Rechtliches“ aus; Fokus an den Rahmen bzw. an den Seitenanfang. Ohne JavaScript und bei Fehlern bleibt das Formular mit Neuladen. `frame-src` nennt die Hosts aller Einbettungen der Seite auch vor der Einwilligung (die Adresse des Inhalts weiterhin erst danach im HTML). Das Skript lädt nur, solange eine Einwilligung offen ist; `test:browser` zählt es nicht zum Budget von drei Skripten.
+
+**Geprüft:** PHPUnit vollständig 644 grün (neu: 204-Antwort mit Cookie, kein Cookie von fremder Herkunft, Weiterleitung ohne Kopfzeile; angepasst: Skript bei offener Frage, `script-src 'none'` nach der Entscheidung, `frame-src` vor der Einwilligung), `npm test` 41, `lint:twig`, php-cs-fixer. Im Browser auf der Hüfner-Kopie: Knopf am Video, „Nur notwendige“ und „Alle akzeptieren“ ohne Neuladen, Fokus aufs Video, ohne JavaScript weiterhin mit Neuladen, keine Konsolenfehler. `test:browser` grün, Lighthouse Produktion Startseite mobil 96, Desktop 98, sonst 100. `test:editor` nicht gelaufen (Editor unverändert, Skript dort nicht eingebunden).
+
+**Veröffentlicht:** Tag `v1.29.0`, Release-Eintrag mit Archiv (3611 Dateien, 5,3 MB, gebaut aus `var/release-source-1.29.0`), `.sha256` und `install.php`; Prüfsumme nach dem Herunterladen bestätigt. Keine Migration.
+
+**Nächster Schritt:** Installationen mit Einwilligungshinweis (huefner-gartenbau.de, Immobilien DEEG) auf 1.29.0 aktualisieren.
+
+## Fassung 1.28.1: weißer 500er bei IONOS durch die Umschreibregel (12.10.2026)
+
+**Anlass:** huefner-gartenbau.de bei IONOS zeigte nach der Einrichtung auf jeder Adresse einen weißen 500er.
+
+**Ursache und Änderung (ADR 114):** PHP 8.4.26 lief (`test.php`), `/index.php/install` lieferte 200, nur umgeschriebene Adressen scheiterten – Umschreibschleife in `public/.htaccess`. Neu im Kern: `RewriteBase /` und `RewriteRule ^index\.php$ - [L]` vor der `!-f`-Regel; Test in `CmsTest::testEveryPublicAnswerCarriesItsProtectiveHeaders`.
+
+**Geprüft:** Umut hat beide Zeilen auf IONOS eingetragen, danach lädt `/install`; auch mit eingeschalteter `Options`-Zeile. PHPUnit vollständig: 643 Tests grün, eine Warnung aus `UpdaterTest` (fehlende `.env` im Testordner, unabhängig von dieser Änderung); php-cs-fixer sauber.
+
+**Veröffentlicht:** Tag `v1.28.1`, Release-Eintrag mit Archiv (3610 Dateien, 5,3 MB, gebaut aus `var/release-source-1.28.1`), `.sha256` und `install.php`; Prüfsumme nach dem Herunterladen bestätigt. Keine Migration.
+
+**Offen:** Der Installer auf huefner-gartenbau.de war bis zum Abschluss der Einrichtung öffentlich erreichbar.
+
+**Nächster Schritt:** Bestehende IONOS-Installationen auf 1.28.1 aktualisieren.
+
+## Hüfner: Änderungen aus dem Kundentermin (12.10.2026)
+
+**Anlass:** Umuts handschriftliche Notizen vom Hüfner-Termin plus Antworten auf Rückfragen. Nur Inhalt und Seed-Skript, kein Kerncode.
+
+**Erledigt (`scripts/seed-huefner.php`, `build-huefner-assets.php`, `reset-huefner.sh`):** Alle Grüntöne auf das Baumgrün des Logos (#067F30) gedreht, „Premium“ und Hervorhebungen in Baumgrün, kleine Schrift auf Dunkel weiß statt hellgrün (Kontrast). Das „💯“ als Umuts Emoji-Bild überall, wo „100“ steht, im Text (`<mark>100</mark>`: die Zahl bleibt lesbar für Vorleser und KI, sichtbar ist das Bild in Schriftgröße, geschütztes Leerzeichen vor „%“); Quelle `100-emoji.png` in den Unterlagen. „Miteinander. 💯 %.“-Abzeichen jetzt dunkel statt rot. Freistellungsbescheinigungen (§ 13b UStG, § 48b EStG) als PDF bei „Planung & Angebot“ und im Fuß, PQ-Bescheinigung unter „Über uns“ und im Fuß, Galabau-Signet und PQ-Logo. Imagevideo (YouTube, youtube-nocookie) als „Externer Inhalt“ – dafür jetzt Einwilligungshinweis (Ecke) und angepasste Datenschutzerklärung. Google-Bewertungen unter „100 % Qualität. 100 % Zufriedenheit.“ mit 4,9 / über 150 als Beleg, drei echte Rezensionen (gekürzt, Namen abgekürzt), Knopf zum Eintrag. 48-h-Angebotsgarantie in Ablauf und Kontakt, „Leistung“ aus dem Formular, Chips verlinken zum Formular, WhatsApp (0176 30387990) in Kontakt und Karriere, 25 Jahre / 7.000+ Projekte, „Bagger bis 15 t“ raus. Karriere: Facharbeiter und LKW-Fahrer C/CE (wie Instagram) als zwei gleich hohe, aufklappbare Karten (details/summary, SVG-Zeichnungen), „Ein Anruf genügt!“. Neue Seite `/alpakas` mit Umuts Text, Ergänzungen, Galerie und Plakat; „Alpakas“ im Menü, „Ablauf“ aus dem Menü raus. `browser-check.mjs`: PDFs zählen beim „erster interner Link“-Klick nicht mit.
+
+**Geprüft:** `test:browser` auf 8102 für `/`, `/alpakas`, `/datenschutz`, `/impressum` grün (HTML Startseite 148.905 B von 150.000 – knapp). Lighthouse Produktion (`reports/lighthouse-huefner-termin`): `/` mobil 96, Desktop 99; `/alpakas` mobil 95, Desktop 100; Barrierefreiheit, Best Practices, SEO, Agentic Browsing überall 100. Im Browser: Video lädt erst nach Einwilligung, Stellenkarten klappen auf, Telefonbreite ohne waagrechtes Scrollen.
+
+**Bekannt / offen:** Die Freistellungsbescheinigung § 13b gilt nur bis 31.12.2026 – dann neue Datei in die Unterlagen und neu aufbauen. Die Alpaka-Videos (mp4) sind nicht eingebunden (keine Videoablage im Kern). Offen von Umut: Logos der Sponsoren, „Über uns – mehr lesen“, ggf. Stellenbilder aus ChatGPT statt der SVG-Zeichnungen, genauer Verbandsname. Die Sprachtest-Kopie (`var/browser-tests/lang`) teilt `var/huefner-media` und hat nach dem Neuaufbau keine passenden Bilder mehr. Sicherung vorher: `var/backups/huefner-vor-termin-1210/`. Nebenbefund Kern: `CustomCode::parse` lehnt `url('…')` mit Anführungszeichen immer ab (optionales Anführungszeichen im regulären Ausdruck backtrackt).
+
+**Nächster Schritt:** Umuts Durchsicht; fehlende Punkte nachliefern lassen.
+
+## Fassung 1.28.0: Notfallseite, Fehlerprotokoll und Update mit einem Klick (09.10.2026)

 **Anlass:** kantarci-reisen.de zeigt nach einer per FTP ersetzten Datenbank auf jeder Adresse eine leere 500-Seite. Umut: „Fang mit 1 und 2 an und verbessere den Update-Prozess … mach es wie bei reiseSoft.“

@@ -8,9 +96,11 @@

 **Geprüft:** PHPUnit vollständig 643 grün (neu: `NotfallTest`, Fortschrittsdatei und vollständiges Zurückschalten in `ArchiveUpdateTest`, Endpunkte nur für Administratoren in `SystemScreenTest`), php-cs-fixer. Im Browser mit einer Installation aus dem Releasearchiv 1.27.1: erfolgreiches Update in einem Klick, Zurückschalten bei einer kaputten Testfassung.

-**Bekannt:** Der neue Ablauf greift erst bei Updates, die von der nächsten Fassung ausgehen. kantarci-reisen.de ist noch offline (Ursache unbekannt, Datenbank lokal mit 1.27.0 lauffähig).
+**Veröffentlicht:** Tag `v1.28.0`, Release-Eintrag mit Archiv (3610 Dateien, 5,3 MB, gebaut aus `var/release-source-1.28.0`), `.sha256` und `install.php`; Prüfsumme nach dem Herunterladen bestätigt. Keine Migration.

-**Nächster Schritt:** Release, dann kantarci-reisen.de wiederherstellen (Notfallschicht hochladen → Protokoll lesen, oder Sicherung zurück) und aktualisieren.
+**Bekannt:** Der neue Ablauf greift erst bei Updates, die von 1.28.0 ausgehen. kantarci-reisen.de ist noch offline (Ursache unbekannt, Datenbank lokal mit 1.27.0 lauffähig).
+
+**Nächster Schritt:** kantarci-reisen.de wiederherstellen (Notfallschicht hochladen → Protokoll lesen, oder Sicherung zurück) und aktualisieren.

 ## Fassung 1.27.1: Update in einem Zug, Kantarci Reisen auf Türkisch (09.10.2026)

@@ -0,0 +1,9 @@
+# Dieser Ordner gehoert nicht ins Netz (ADR 116). Zeigt die Domain richtig auf public/, wird diese
+# Datei nie gelesen; zeigt sie versehentlich auf den Projektordner, sperrt sie hier alles.
+<IfModule mod_authz_core.c>
+    Require all denied
+</IfModule>
+<IfModule !mod_authz_core.c>
+    Order deny,allow
+    Deny from all
+</IfModule>
@@ -0,0 +1,32 @@
+<?php
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+final class Version20261012000100 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Geplante Veröffentlichung: welche Fassung zum Termin online geht (ADR 116).';
+    }
+
+    public function isTransactional(): bool
+    {
+        return false;
+    }
+
+    public function up(Schema $schema): void
+    {
+        // Bisher ging zum Termin der jeweils neueste Entwurf online - auch einer, den nach dem
+        // Planen jemand ohne Recht zum Veröffentlichen gespeichert hatte. Jetzt merkt sich die
+        // Planung die Fassung, die beim Planen vorlag. Eine Spalte, kein Tabellenneubau.
+        $schema->getTable('page')->addColumn('publish_revision_id', 'string', ['length' => 32, 'notnull' => false, 'default' => null]);
+    }
+
+    public function down(Schema $schema): void
+    {
+        $schema->getTable('page')->dropColumn('publish_revision_id');
+    }
+}
@@ -0,0 +1,9 @@
+# Dieser Ordner gehoert nicht ins Netz (ADR 116). Zeigt die Domain richtig auf public/, wird diese
+# Datei nie gelesen; zeigt sie versehentlich auf den Projektordner, sperrt sie hier alles.
+<IfModule mod_authz_core.c>
+    Require all denied
+</IfModule>
+<IfModule !mod_authz_core.c>
+    Order deny,allow
+    Deny from all
+</IfModule>
@@ -2,7 +2,14 @@ DirectoryIndex index.php
 Options -Indexes -MultiViews

 # Alles, was keine Datei ist, beantwortet PHP.
+#
+# Die Zeile fuer index.php selbst ist kein Zierrat: Bei IONOS erkennt !-f die bereits
+# umgeschriebene index.php nicht als Datei, die Regel greift wieder und wieder, und Apache bricht
+# nach zehn Runden mit einem weissen 500er ab (huefner-gartenbau.de, 12.10.2026). Dieselbe
+# Absicherung steht in der .htaccess von WordPress.
 RewriteEngine On
+RewriteBase /
+RewriteRule ^index\.php$ - [L]
 RewriteCond %{REQUEST_FILENAME} !-f
 RewriteRule ^ index.php [L]

@@ -1,3 +1,5 @@
+/* Der Strich aller Symbole aus icon.html.twig, wie auf der Website (site.css). */
+svg.block-icon{fill:none;stroke:currentColor;stroke-width:1.6;stroke-linecap:round;stroke-linejoin:round}
 /* Administration: shared foundation and the management screens.
   The editor has its own stylesheet (editor.css) that only the editor and the media page load. */

@@ -0,0 +1,91 @@
+// Einwilligung ohne Neuladen (ADR 115).
+//
+// Ohne dieses Skript schicken der Hinweis und der Knopf am eingebetteten Inhalt ein Formular ab,
+// der Server setzt das Cookie und leitet auf dieselbe Seite zurück - die Seite lädt neu. Mit dem
+// Skript geht dasselbe Formular im Hintergrund an denselben Endpunkt; die Kopfzeile
+// X-Kant-Consent sagt dem Server, dass keine Weiterleitung nötig ist. Danach holt das Skript die
+// Seite noch einmal und übernimmt daraus nur, was sich durch die Entscheidung ändert: die
+// eingebetteten Inhalte und die Zeile „Rechtliches“. Die Adresse eines Inhalts steht so weiterhin
+// erst nach der Einwilligung im Dokument.
+//
+// Geht dabei etwas schief, schickt das Skript das Formular ganz normal ab: lieber einmal neu
+// laden als eine Entscheidung, die nicht ankommt.
+(() => {
+  const forms = document.querySelectorAll('.consent-bar form, .embed-blocked form');
+  if (forms.length === 0) {
+    return;
+  }
+
+  const replaceFrom = async () => {
+    const response = await fetch(location.href, { credentials: 'same-origin', headers: { Accept: 'text/html' } });
+    if (!response.ok) {
+      throw new Error('Seite nicht geladen');
+    }
+    const fresh = new DOMParser().parseFromString(await response.text(), 'text/html');
+    for (const blocked of document.querySelectorAll('.embed-blocked[id]')) {
+      const next = fresh.getElementById(blocked.id);
+      if (next && !next.classList.contains('embed-blocked')) {
+        blocked.replaceWith(document.importNode(next, true));
+      }
+    }
+    for (const legal of document.querySelectorAll('.block-legal[id]')) {
+      const next = fresh.getElementById(legal.id);
+      if (next) {
+        legal.replaceWith(document.importNode(next, true));
+      }
+    }
+  };
+
+  for (const form of forms) {
+    form.addEventListener('submit', async (event) => {
+      event.preventDefault();
+      const button = event.submitter;
+      const body = new FormData(form, button);
+      const placeholder = form.closest('.embed-blocked');
+      for (const control of form.querySelectorAll('button')) {
+        control.disabled = true;
+      }
+      try {
+        const saved = await fetch(form.action, { method: 'POST', body, credentials: 'same-origin', headers: { 'X-Kant-Consent': '1' } });
+        if (!saved.ok) {
+          throw new Error('Entscheidung nicht gespeichert');
+        }
+        // Wer etwas erlaubt hat, bekommt die Inhalte jetzt; wer abgelehnt hat, braucht keinen
+        // zweiten Abruf - es ändert sich nichts außer dem Hinweis.
+        if (body.get('choice') !== 'none' && document.querySelector('.embed-blocked')) {
+          await replaceFrom();
+        }
+        document.querySelector('.consent-bar')?.remove();
+        if (placeholder) {
+          // Der Knopf ist mit dem Platzhalter verschwunden; der Fokus geht an den Inhalt, der an
+          // seiner Stelle steht.
+          const frame = document.getElementById(placeholder.id)?.querySelector('iframe');
+          frame?.focus();
+        } else {
+          // Entschieden im Hinweis: der Fokus beginnt wieder am Seitenanfang, wie nach dem
+          // Neuladen - der nächste Tab führt zu „Zum Inhalt springen“.
+          document.getElementById('seitenanfang')?.focus({ preventScroll: true });
+        }
+      } catch {
+        // Rückfall: das Formular normal absenden, samt gedrücktem Knopf.
+        for (const control of form.querySelectorAll('button')) {
+          control.disabled = false;
+        }
+        withChoice(form, button).submit();
+      }
+    });
+  }
+
+  // form.submit() schickt den gedrückten Knopf nicht mit; sein Wert wandert als verstecktes Feld
+  // ins Formular, damit der Rückfall dieselbe Entscheidung sendet.
+  function withChoice(form, button) {
+    if (button?.name) {
+      const field = document.createElement('input');
+      field.type = 'hidden';
+      field.name = button.name;
+      field.value = button.value;
+      form.append(field);
+    }
+    return form;
+  }
+})();
@@ -107,6 +107,10 @@ export const ICON_PATHS = {
  hardware: 'M4 5h16v11H4Zm4 15h8m-4-4v4',
  network: 'M5 3h14v5H5Zm0 13h14v5H5Zm7-8v8M8 8v3h8V8',
  design: 'M4 20h16M6 16 18 4l3 3L9 19l-4 1Z',
+  // Soziale Netzwerke
+  facebook: 'M15.5 4h-2.2A3.8 3.8 0 0 0 9.5 7.8V10H7v3.2h2.5V20h3.3v-6.8h2.4l.5-3.2h-2.9V8.2c0-.6.3-.9.9-.9h2Z',
+  instagram: 'M8.1 3.5h7.8a4.6 4.6 0 0 1 4.6 4.6v7.8a4.6 4.6 0 0 1-4.6 4.6H8.1a4.6 4.6 0 0 1-4.6-4.6V8.1a4.6 4.6 0 0 1 4.6-4.6ZM12 8.1a3.9 3.9 0 1 0 0 7.8 3.9 3.9 0 0 0 0-7.8ZM17 7h.01',
+  whatsapp: 'M4 20l1.4-4A8.5 8.5 0 1 1 8.6 19.1ZM9.3 9.2c0 3 2.5 5.5 5.5 5.5l1.3-1.4-2-.9-.9.8a4.1 4.1 0 0 1-2.3-2.3l.8-.9-.9-2Z',
 };

 export const ICON_LABELS = {
@@ -130,6 +134,7 @@ export const ICON_LABELS = {
  check: 'Häkchen', 'check-circle': 'Häkchen im Kreis', info: 'Info', help: 'Frage', alert: 'Warnung',
  search: 'Suche', settings: 'Einstellungen', filter: 'Filter', grid: 'Raster', list: 'Liste', sparkle: 'Funkeln',
  coffee: 'Kaffee', utensils: 'Besteck', laptop: 'Laptop', hardware: 'Bildschirm', network: 'Netzwerk', design: 'Stift',
+  facebook: 'Facebook', instagram: 'Instagram', whatsapp: 'WhatsApp',
 };

 /** Die Kategorien des Auswahlfensters, in der Reihenfolge der Reiter. Jedes Symbol steht genau einmal. */
@@ -141,6 +146,7 @@ export const ICON_GROUPS = [
  ['Personen & Sicherheit', ['user', 'people', 'login', 'lock', 'key', 'shield', 'eye', 'thumbs-up', 'award', 'graduation', 'heart', 'star']],
  ['Haus & Handwerk', ['home', 'building', 'wrench', 'hammer', 'brush', 'ruler', 'leaf', 'tree', 'sun', 'droplet', 'flame', 'bolt', 'solar', 'thermometer', 'snowflake', 'car']],
  ['Allgemein', ['check', 'check-circle', 'info', 'help', 'alert', 'search', 'settings', 'filter', 'grid', 'list', 'sparkle', 'coffee', 'utensils', 'laptop', 'hardware', 'network', 'design']],
+  ['Soziale Netzwerke', ['facebook', 'instagram', 'whatsapp']],
 ];

 const svgNS = 'http://www.w3.org/2000/svg';
@@ -1,4 +1,7 @@
 /**
+ * Das kleine Skript des Kopfbereichs: markiert die gescrollte Seite und schließt das Menü nach
+ * einer Wahl (initMenus, unten).
+ *
 * Marks the page as scrolled.
 *
 * A header can carry a second set of colours for the scrolled page - transparent over the hero,
@@ -31,4 +34,26 @@ export function initScrolled(doc = document) {
  };
 }

-if (!document.querySelector('#editor')) initScrolled();
+/**
+ * Schließt das aufgeklappte Menü, sobald darin etwas gewählt wird (ADR 119).
+ *
+ * Ein Sprungziel wie #kontakt bleibt auf derselben Seite - das `details` blieb offen und lag über
+ * dem Ziel. Bei einem Link auf eine andere Seite stand es nach „Zurück“ (Seiten-Cache des
+ * Browsers) noch offen da. Ohne Skript bleibt es beim Klappen von Hand und beim Klick daneben.
+ */
+export function initMenus(doc = document) {
+  const onClick = (event) => {
+    const link = event.target.closest?.('.menu-burger-body a');
+    const menu = link?.closest('details.menu-burger');
+    if (menu) {
+      menu.open = false;
+    }
+  };
+  doc.addEventListener('click', onClick);
+  return () => doc.removeEventListener('click', onClick);
+}
+
+if (!document.querySelector('#editor')) {
+  initScrolled();
+  initMenus();
+}
@@ -264,6 +264,8 @@ body.consent-open{padding-bottom:320px}
 /* A single icon, sized by class because inline styles are forbidden by the policy. */
 .block-icon{display:inline-flex;align-items:center;justify-content:center;color:var(--accent);line-height:0}
 .block-icon svg{width:100%;height:100%;display:block}
+/* Der Strich aller Symbole (icon.html.twig) - einmal hier statt als Attribute an jedem einzelnen. */
+svg.block-icon{fill:none;stroke:currentColor;stroke-width:1.6;stroke-linecap:round;stroke-linejoin:round}
 /* Das eingebettete SVG traegt dieselbe Klasse wie seine Huelle und setzte deshalb die
   Akzentfarbe erneut - eine am Symbolblock eingestellte Farbe kam nie an. */
 .block-icon .block-icon{color:inherit}
@@ -475,6 +477,12 @@ body.consent-open{padding-bottom:320px}
  .menu-collapse-mobile>.menu-list{display:none}
 }
 .menu-burger>summary{min-height:44px;min-width:44px}
+/* Ein Klick neben das aufgeklappte Menue schliesst es - ohne Skript: Solange es offen ist, liegt
+   eine unsichtbare Flaeche ueber der Seite, die zum Menue-Knopf gehoert. Ein Klick darauf ist ein
+   Klick auf den Knopf, und der klappt zu. Die Flaeche des Menues liegt darueber und bleibt
+   bedienbar; :where() haelt die Regel schwaecher als die Platzierung im Kopfbereich. */
+.menu-burger[open]>summary::before{content:'';position:fixed;top:0;right:0;bottom:0;left:0;z-index:29;cursor:default}
+:where(.menu-burger[open])>.menu-burger-body{position:relative;z-index:30}
 .menu-burger-body{overflow-wrap:anywhere}
 /* Im Kopfbereich klappt das Menue als Flaeche unter dem Kopf auf, ueber die volle Breite.
   Inline geoeffnet stand es sonst in der schmalen Spalte neben der Marke und schob den
@@ -69,7 +69,8 @@ try {
      const queries = Number(response.headers()['x-kant-queries'] ?? -1);
      const html = (await response.text()).length;
      const styles = [...transferred.values()].filter(entry => entry.type === 'text/css').reduce((sum, entry) => sum + entry.length, 0);
-      const scripts = [...transferred.values()].filter(entry => entry.type.includes('javascript')).length;
+      // consent.js zählt nicht: nur solange eine Einwilligung offen ist (ADR 115).
+      const scripts = [...transferred.entries()].filter(([url, entry]) => entry.type.includes('javascript') && !url.includes('/assets/consent.js')).length;
      const requests = transferred.size;
      // Bilder gehören zum Inhalt: eine bebilderte Startseite lädt zu Recht mehr Dateien als eine
      // Textseite. Gedeckelt wird deshalb das Beiwerk (Stile, Schriften, Skripte) und das
@@ -114,7 +115,9 @@ try {
      assert.equal(await page.locator('h1').count(), 1);
      // Strukturierte Daten stehen zwar in einem script-Element, führen aber nichts aus. Gezählt
      // wird, was laufen kann - und das nur, wenn die Seite es in ihrer eigenen Richtlinie erlaubt.
-      const laufend = await page.locator('script:not([type="application/ld+json"])').count();
+      // consent.js zählt nicht mit: Es steht nur auf der Seite, solange eine Einwilligung offen ist,
+      // und nach der Entscheidung nicht mehr (ADR 115).
+      const laufend = await page.locator('script:not([type="application/ld+json"]):not([src^="/assets/consent.js"])').count();
      const darfSkripte = !/script-src 'none'/.test(response.headers()['content-security-policy'] ?? '');
      assert.ok(darfSkripte ? laufend <= 3 : 0 === laufend, `${path}: ${laufend} Skript(e), erlaubt ${darfSkripte ? 3 : 0}`);
      // Einblendungen zu Ende spielen, bevor gemessen wird: mitten in einer Einblendung ist ein
@@ -162,7 +165,8 @@ try {
    const hinweis = page.locator('.consent-bar button[value="none"]');
    if (await hinweis.count()) {
        await hinweis.click();
-        await page.waitForLoadState('domcontentloaded');
+        // Mit consent.js ohne Neuladen (ADR 115): warten, bis der Hinweis weg ist.
+        await page.locator('.consent-bar').waitFor({ state: 'detached' });
    }
    await page.keyboard.press('Tab');
    assert.equal(await page.locator(':focus').innerText(), 'Zum Inhalt springen');
@@ -171,7 +175,8 @@ try {
    // Weiter mit der Tastatur: der erste Verweis im Inhalt muss anklickbar sein und tatsächlich
    // woandershin führen. Vorher standen hier die Linktexte der Demo - gegen jede andere
    // Installation lief die Prüfung damit ins Leere statt etwas zu prüfen.
-    const ersterLink = page.locator('main a[href^="/"]').first();
+    // Ein PDF zum Herunterladen ist keine Seite mit Überschrift; es zählt hier nicht mit.
+    const ersterLink = page.locator('main a[href^="/"]:not([href$=".pdf"])').first();
    const ziel = await ersterLink.getAttribute('href');
    await ersterLink.click();
    assert.equal(new URL(page.url()).pathname, ziel.split('#')[0] || '/');
@@ -189,7 +194,7 @@ try {
      await noJs.waitForLoadState('domcontentloaded');
  }
  assert.equal(await noJs.locator('h1').count(), 1);
-  const ohneJs = noJs.locator('main a[href^="/"]').first();
+  const ohneJs = noJs.locator('main a[href^="/"]:not([href$=".pdf"])').first();
  const zielOhneJs = await ohneJs.getAttribute('href');
  await ohneJs.click();
  assert.equal(new URL(noJs.url()).pathname, zielOhneJs.split('#')[0] || '/');
@@ -4,10 +4,15 @@
 * Bereitet die Bilder des Hüfner-Entwurfs für die Mediathek vor.
 *
 * Kopiert die Fotos und das Logo aus dem gelieferten Ordner (images/) und schneidet aus dem Logo
- * den Baum mit den Steinen als quadratisches Seitensymbol (favicon.png) heraus. Der Baum ist im
+ * den Baum (ohne die Steine) als quadratisches Seitensymbol (favicon.png) heraus. Der Baum ist im
 * Logo links, der Schriftzug rechts; ein Favicon mit Schrift wäre in 32 px unlesbar.
 *
- * Aufruf: php scripts/build-huefner-assets.php <Quellordner mit images/> <Zielordner>
+ * Aufruf: php scripts/build-huefner-assets.php <Quellordner mit images/> <Zielordner> [<Unterlagen>]
+ *
+ * Das dritte Argument ist Umuts Ordner „unterlagenfrwebsite“ (12.10.2026): Alpaka-Fotos, PQ-Logo,
+ * Galabau-Signet und die drei PDFs. Sie bekommen hier feste, einfache Namen, damit das Seed-Skript
+ * nicht an „Freistellungsbescheinigung §48 … bis 11.05.2029.pdf“ hängt. Kommt eine neue
+ * Bescheinigung, genügt es, sie nach dem gleichen Muster benannt in den Ordner zu legen.
 */
 $quelle = rtrim($argv[1] ?? '', '/\\');
 $ziel = rtrim($argv[2] ?? '', '/\\');
@@ -24,22 +29,76 @@ foreach (glob($quelle.'/images/*.{jpg,png}', GLOB_BRACE) ?: [] as $datei) {
    copy($datei, $ziel.'/'.basename($datei));
 }

-// Baum und Steine: im 1600 x 607 px großen Logo etwa x 15–500, y 10–560.
+// Nur der Baum: Krone (grün) und Stamm (dunkel) aus dem linken Teil des Logos, ohne die grauen
+// Steine - die liefen bisher rechts aus dem Ausschnitt und sind in 32 px nur Rauschen (Umut,
+// 12.10.2026: „schneide bitte den Baum zurecht“). Der Stamm ist dunkler als die Steine.
 $logo = imagecreatefrompng($quelle.'/images/logo.png');
 if (false === $logo) {
    fwrite(STDERR, "logo.png lässt sich nicht lesen.\n");
    exit(1);
 }
+$punkte = [];
+[$bx0, $by0, $bx1, $by1] = [PHP_INT_MAX, PHP_INT_MAX, 0, 0];
+for ($y = 10; $y < 520; ++$y) {
+    for ($x = 10; $x < 500; ++$x) {
+        $c = imagecolorat($logo, $x, $y);
+        if ((($c >> 24) & 127) > 100) {
+            continue;
+        }
+        [$r, $g, $b] = [($c >> 16) & 255, ($c >> 8) & 255, $c & 255];
+        if ($g > $r + 30 || ($r + $g + $b) / 3 < 70) {
+            $punkte[] = [$x, $y, $c];
+            [$bx0, $by0, $bx1, $by1] = [min($bx0, $x), min($by0, $y), max($bx1, $x), max($by1, $y)];
+        }
+    }
+}
+$baum = imagecreatetruecolor($bx1 - $bx0 + 1, $by1 - $by0 + 1);
+imagesavealpha($baum, true);
+imagealphablending($baum, false);
+imagefill($baum, 0, 0, imagecolorallocatealpha($baum, 0, 0, 0, 127));
+foreach ($punkte as [$x, $y, $c]) {
+    imagesetpixel($baum, $x - $bx0, $y - $by0, $c);
+}
 $kante = 512;
 $symbol = imagecreatetruecolor($kante, $kante);
 imagesavealpha($symbol, true);
 imagealphablending($symbol, false);
 imagefill($symbol, 0, 0, imagecolorallocatealpha($symbol, 0, 0, 0, 127));
-imagealphablending($symbol, true);
-[$x, $y, $b, $h] = [15, 10, 490, 550];
-$massstab = min(($kante - 24) / $b, ($kante - 24) / $h);
+[$b, $h] = [imagesx($baum), imagesy($baum)];
+$massstab = min(($kante - 32) / $b, ($kante - 32) / $h);
 $zb = (int) round($b * $massstab);
 $zh = (int) round($h * $massstab);
-imagecopyresampled($symbol, $logo, (int) (($kante - $zb) / 2), (int) (($kante - $zh) / 2), $x, $y, $zb, $zh, $b, $h);
+imagecopyresampled($symbol, $baum, (int) (($kante - $zb) / 2), (int) (($kante - $zh) / 2), 0, 0, $zb, $zh, $b, $h);
 imagepng($symbol, $ziel.'/favicon.png');
 echo "Bilder kopiert, Seitensymbol geschnitten: $ziel\n";
+
+$unterlagen = rtrim($argv[3] ?? '', '/\\');
+if ('' === $unterlagen) {
+    exit(0);
+}
+// Muster im Ordner => fester Name. Bei mehreren Treffern gewinnt der letzte in Namensreihenfolge.
+$feste = [
+    'Alpaka (1).jpeg' => 'alpaka-plakat.jpg',
+    'Alpaka (2).jpeg' => 'alpaka-wiese.jpg',
+    'Alpaka (3).jpeg' => 'alpaka-stall.jpg',
+    'Alpaka (4).jpeg' => 'alpaka-blume.jpg',
+    'Alpaka (6).jpeg' => 'alpaka-zaunbau.jpg',
+    'Alpaka (9).jpeg' => 'alpaka-rasen.jpg',
+    'PQ-Logo*.png' => 'pq-logo.png',
+    'Signum*.png' => 'galabau-signet.png',
+    '100-emoji.png' => 'hundert.png',
+    'PQ-Bescheinigung*.pdf' => 'pq-bescheinigung.pdf',
+    'Freistellungsbescheinigung §13*.pdf' => 'freistellung-13b.pdf',
+    'Freistellungsbescheinigung §48*.pdf' => 'freistellung-48b.pdf',
+];
+$dateien = scandir($unterlagen) ?: [];
+foreach ($feste as $muster => $name) {
+    $treffer = array_values(array_filter($dateien, static fn (string $d): bool => fnmatch($muster, $d, FNM_NOESCAPE)));
+    if ([] === $treffer) {
+        fwrite(STDERR, "Fehlt in den Unterlagen: $muster\n");
+        exit(1);
+    }
+    sort($treffer);
+    copy($unterlagen.'/'.end($treffer), $ziel.'/'.$name);
+}
+echo 'Unterlagen übernommen: '.count($feste)." Dateien\n";
@@ -67,7 +67,7 @@ echo "Fassung {$version}\n";
 // migrations.php und cli-config.php gehoeren dazu: ohne die erste findet Doctrine beim
 // Einrichten keine Migrationsliste und bricht mit "configuration file does not exist" ab - genau
 // dort, wo eine frische Installation ihre Tabellen anlegen will.
-$include = ['bin', 'config', 'migrations', 'plugins', 'public', 'src', 'templates', 'composer.json', 'composer.lock', 'migrations.php', 'cli-config.php', 'VERSION', 'README.md', '.env.example'];
+$include = ['bin', 'config', 'migrations', 'plugins', 'public', 'src', 'templates', 'composer.json', 'composer.lock', 'migrations.php', 'cli-config.php', 'VERSION', 'README.md', '.env.example', '.htaccess'];
 $skip = ['.git', '.github', '.claude', '.gitattributes', '.gitignore', '.env.lock', '.php-cs-fixer.cache', 'node_modules', 'var', 'tests', 'scripts', 'reports', 'phpunit.xml.dist', '.php-cs-fixer.dist.php', 'package.json', 'package-lock.json', 'AGENTS.md', 'ENTWICKLUNGSPLAN.md', 'docs', 'composer.phar', '.venv', 'vendor', 'phpunit.cache', 'migrations.php.bak'];

 $copy = static function (string $from, string $to) use (&$copy, $skip): int {
@@ -116,6 +116,8 @@ if (!$ok) {
    exit(1);
 }
 echo 'vendor/ gebaut'.($flags ? ' ohne Entwicklungspakete' : ' MIT Entwicklungspaketen')."\n";
+// vendor/ gehört nicht ins Netz, auch wenn die Domain falsch zeigt (ADR 116).
+copy($root.'/config/schutz/sperren.htaccess', $staging.'/vendor/.htaccess');

 // The environment file is not part of a release: it holds the secret of one installation.
 foreach (['.env.local', '.env.prod.local'] as $secret) {
@@ -17,6 +17,9 @@
 *   Eintrag wie ../../.env landet nirgends.
 * - Sie arbeitet nur in ein leeres Verzeichnis. Eine bestehende Installation wird nicht
 *   überschrieben, auch nicht teilweise.
+ * - Nach dem Entpacken legt sie den Installationsschlüssel an (var/install.key, ADR 116) und
+ *   zeigt ihn nur auf ihrer Abschlussseite. Ohne ihn öffnet sich der Installer nicht - wer die
+ *   frische Installation zuerst aufruft, kann sie so nicht übernehmen.
 */

 // Vom Buildskript gesetzt: `php scripts/build-release.php` schreibt Adresse und Prüfsumme des
@@ -176,6 +179,27 @@ function kant_checks(string $target): array
    return $checks;
 }

+/** Legt den Installationsschlüssel an (oder liest einen vorhandenen) und gibt ihn zurück. */
+function kant_install_key(string $target): string
+{
+    $file = $target.'/var/install.key';
+    $key = is_file($file) ? trim((string) file_get_contents($file)) : '';
+    if (1 === preg_match('/^[a-f0-9]{32}$/D', $key)) {
+        return $key;
+    }
+    if (!is_dir($target.'/var')) {
+        mkdir($target.'/var', 0775, true);
+    }
+    $key = bin2hex(random_bytes(16));
+    if (false === file_put_contents($file, $key."
+")) {
+        throw new RuntimeException('Der Installationsschlüssel ließ sich nicht schreiben (var/install.key).');
+    }
+    @chmod($file, 0600);
+
+    return $key;
+}
+
 /** Der Ablauf, wenn der Knopf gedrückt wurde. Gibt [Erfolg, Meldung] zurück. */
 function kant_run(string $target): array
 {
@@ -192,6 +216,7 @@ function kant_run(string $target): array
            return [false, 'Die Prüfsumme des heruntergeladenen Archivs stimmt nicht. Erwartet: '.KANT_ARCHIVE_SHA256.', erhalten: '.$hash.'. Es wurde nichts entpackt.'];
        }
        $files = kant_unpack($archive, $target);
+        kant_install_key($target);

        return [true, 'Entpackt: '.$files.' Dateien.'];
    } catch (Throwable $e) {
@@ -259,7 +284,9 @@ header('X-Robots-Tag: noindex, nofollow');
    <h1>Die Dateien liegen.</h1>
    <p class="lead">Diese Datei hat sich selbst gelöscht. Weiter geht es mit der Einrichtung: Datenbank, Konto, Website.</p>
    <p class="notice done"><?= $e($message) ?></p>
-    <p><a href="install">Zur Einrichtung →</a></p>
+    <?php $key = kant_install_key($target); ?>
+    <p>Dein Installationsschlüssel: <code><?= $e($key) ?></code><br><span style="font-size:13px;color:#5d6b62">Nur diese Seite zeigt ihn an. Der Verweis unten trägt ihn schon; liegt er dir nicht mehr vor, steht er in <code>var/install.key</code>.</span></p>
+    <p><a href="install/schluessel?schluessel=<?= $e($key) ?>" rel="noreferrer">Zur Einrichtung →</a></p>
    <p style="font-size:13px;color:#5d6b62">Führt der Verweis ins Leere, zeigt die Domain nicht auf <code>public/</code>. Das muss beim Hoster eingestellt werden – ohne das wären auch <code>.env</code> und <code>var/</code> über das Netz erreichbar.</p>
 <?php } else { ?>
    <h1>KantSites installieren</h1>
@@ -1,6 +1,7 @@
 #!/bin/sh
 # Wirft die Hüfner-Installation weg und baut sie neu auf. Nur fuer den Aufbau gedacht.
 # Erstes Argument: der entpackte Entwurf (Ordner mit index.html und images/).
+# Zweites Argument: Umuts Unterlagen (Alpakas, PQ, Freistellungsbescheinigungen, Signet).
 set -e
 root="C:/Django Project/KantSites"
 php="${PHP_BINARY:-C:/php84/php.exe}"
@@ -8,10 +9,10 @@ export DATABASE_URL="sqlite:///$root/var/huefner.db"
 export MEDIA_DIRECTORY="$root/var/huefner-media"
 assets="$root/var/huefner-assets"
 if [ -n "$1" ]; then
-  "$php" scripts/build-huefner-assets.php "$1" "$assets"
+  "$php" scripts/build-huefner-assets.php "$1" "$assets" "$2"
 fi
-if [ ! -f "$assets/favicon.png" ]; then
-  echo "Bilder fehlen: erst mit dem Ordner des Entwurfs als Argument aufrufen." >&2
+if [ ! -f "$assets/favicon.png" ] || [ ! -f "$assets/pq-bescheinigung.pdf" ]; then
+  echo "Bilder fehlen: erst mit dem Ordner des Entwurfs und den Unterlagen als Argumente aufrufen." >&2
  exit 1
 fi
 rm -f "$root/var/huefner.db"
@@ -24,3 +25,7 @@ if [ -f "$root/var/cacert.pem" ]; then
 else
  "$php" bin/console cms:fonts:fetch
 fi
+# Das Inhaltspaket für die Live-Seite (ADR 118): dort unter System → Inhalte übertragen importieren.
+# Konten bleiben dabei, wie sie live sind.
+rm -f "$root/var/huefner-paket.zip"
+"$php" bin/console cms:paket:export --ziel="$root/var/huefner-paket.zip"
@@ -0,0 +1,9 @@
+# Dieser Ordner gehoert nicht ins Netz (ADR 116). Zeigt die Domain richtig auf public/, wird diese
+# Datei nie gelesen; zeigt sie versehentlich auf den Projektordner, sperrt sie hier alles.
+<IfModule mod_authz_core.c>
+    Require all denied
+</IfModule>
+<IfModule !mod_authz_core.c>
+    Order deny,allow
+    Deny from all
+</IfModule>
@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Command;
+
+use App\Domain\InvalidPage;
+use App\Ops\SitePackage;
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+#[AsCommand(name: 'cms:paket:export', description: 'Writes a content package (pages, media, forms, design, settings) for import into another installation (ADR 118).')]
+final class PackageExportCommand extends Command
+{
+    public function __construct(private SitePackage $packages)
+    {
+        parent::__construct();
+    }
+
+    protected function configure(): void
+    {
+        $this->addOption('mit-benutzern', null, InputOption::VALUE_NONE, 'Konten mit Passwort-Hashes mitnehmen.')
+            ->addOption('ziel', null, InputOption::VALUE_REQUIRED, 'Pfad der Zip-Datei (Standard: var/pakete/paket-<website>-<zeit>.zip).');
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $io = new SymfonyStyle($input, $output);
+        try {
+            $file = $this->packages->export((bool) $input->getOption('mit-benutzern'), $input->getOption('ziel') ?: null);
+        } catch (InvalidPage $e) {
+            $io->error($e->getMessage());
+
+            return Command::FAILURE;
+        }
+        $manifest = $this->packages->inspect($file);
+        $io->success(sprintf('%s: %d Seite(n), %d Mediendatei(en), Konten %s.', $file, (int) ($manifest['inhalt']['page'] ?? 0), (int) $manifest['medien'], $manifest['benutzer'] ? 'enthalten' : 'nicht enthalten'));
+
+        return Command::SUCCESS;
+    }
+}
@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Command;
+
+use App\Ops\SitePackage;
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+#[AsCommand(name: 'cms:paket:import', description: 'Replaces the content of this installation with a content package; accounts stay unless --mit-benutzern (ADR 118).')]
+final class PackageImportCommand extends Command
+{
+    public function __construct(private SitePackage $packages)
+    {
+        parent::__construct();
+    }
+
+    protected function configure(): void
+    {
+        $this->addArgument('datei', InputArgument::REQUIRED, 'Die Zip-Datei des Pakets.')
+            ->addOption('mit-benutzern', null, InputOption::VALUE_NONE, 'Konten und Passwörter aus dem Paket übernehmen.')
+            ->addOption('ja', null, InputOption::VALUE_NONE, 'Ohne Rückfrage ersetzen.');
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $io = new SymfonyStyle($input, $output);
+        $file = (string) $input->getArgument('datei');
+        if (!$input->getOption('ja') && !$io->confirm('Die Inhalte dieser Installation werden ersetzt (vorher wird gesichert). Weiter?', false)) {
+            return Command::FAILURE;
+        }
+        $result = $this->packages->import($file, (bool) $input->getOption('mit-benutzern'));
+        foreach ($result['steps'] as $step) {
+            $io->writeln(sprintf('%s %s: %s', $step['ok'] ? 'ok    ' : 'FEHLER', $step['step'], $step['detail']));
+        }
+
+        return $result['ok'] ? Command::SUCCESS : Command::FAILURE;
+    }
+}
@@ -141,8 +141,15 @@ final class CustomCode
        if (1 !== preg_match('/^[a-zA-Z0-9_-]{1,64}$/D', $blockId)) {
            return '';
        }
+        // Gespeichert wurde nur, was beim Speichern galt. Ist eine Regel inzwischen strenger
+        // (ADR 116), fällt das CSS dieses einen Blocks weg - die Seite selbst bleibt erreichbar.
+        try {
+            $rules = $this->parse($css);
+        } catch (InvalidDocument) {
+            return '';
+        }
        $out = '';
-        foreach ($this->parse($css) as $suffix => $declarations) {
+        foreach ($rules as $suffix => $declarations) {
            if ('' === $declarations) {
                continue;
            }
@@ -193,6 +200,13 @@ final class CustomCode
            if (1 !== preg_match('/^[a-zA-Z0-9 .:>+~_\[\]="\'-]*$/D', $suffix)) {
                throw new InvalidDocument(sprintf('„&%s“ ist als verschachtelter Selektor nicht erlaubt.', $suffix));
            }
+            // Geschwister des Elements selbst (`& ~ *`, `& + p`) liegen außerhalb des Blocks - damit
+            // ließe sich die ganze Seite umgestalten. Innerhalb des Blocks bleiben `~` und `+`
+            // erlaubt. Und Anführungszeichen paarweise: ein offener String verschluckte sonst
+            // alle folgenden Regeln der Seite (ADR 116).
+            if (1 === preg_match('/^\s*[~+]/', $suffix) || 0 !== substr_count($suffix, '"') % 2 || 0 !== substr_count($suffix, "'") % 2) {
+                throw new InvalidDocument(sprintf('„&%s“ reicht über den Block hinaus und ist deshalb nicht erlaubt.', $suffix));
+            }
            // Zusammenfuegen statt ersetzen: zweimal derselbe Selektor ist in CSS eine Kaskade,
            // nicht ein Widerruf. Vorher gewann die letzte Regel, und alles, was nur in der
            // ersten stand, verschwand ohne Meldung - gefunden am Projektraster von EB Solar,
@@ -247,7 +261,8 @@ final class CustomCode
                $out[] = $property.':'.$value;
                continue;
            }
-            if ('' === $value || 1 !== preg_match('/^[a-zA-Z0-9 ,.%#()\/:_+*-]{1,300}$/D', $value)) {
+            // Kein Kommentaranfang und -ende: ein offener Kommentar verschluckte die Regeln danach.
+            if ('' === $value || 1 !== preg_match('/^[a-zA-Z0-9 ,.%#()\/:_+*-]{1,300}$/D', $value) || str_contains($value, '/*') || str_contains($value, '*/')) {
                throw new InvalidDocument(sprintf('Der Wert von „%s“ enthält Zeichen, die in eigenem CSS nicht vorgesehen sind.', $property));
            }
            $out[] = $property.':'.$value;
@@ -16,7 +16,7 @@ final class DocumentValidator
    /** Blocks introduced with schema v6 for the sections a marketing page actually needs. */
    public const V6_TYPES = ['iconcard', 'stat', 'quote', 'logos', 'cta', 'contact', 'divider', 'spacer', 'accordion', 'accordionitem'];
    /** Icons ship as inline SVG from this fixed list; no icon font and no external request. */
-    public const ICONS = ['arrow-up-right', 'arrow-right', 'arrow-left', 'arrow-up', 'arrow-down', 'chevron-right', 'chevron-left', 'chevron-up', 'chevron-down', 'arrow-circle', 'external', 'refresh', 'menu', 'close', 'plus', 'minus', 'phone', 'app', 'mail', 'chat', 'send', 'calendar', 'clock', 'pin', 'map', 'navigation', 'web', 'wifi', 'support', 'shop', 'cart', 'tag', 'euro', 'credit-card', 'gift', 'percent', 'truck', 'package', 'briefcase', 'document', 'download', 'upload', 'print', 'link', 'share', 'image', 'camera', 'video', 'play', 'pause', 'music', 'mic', 'book', 'user', 'people', 'login', 'lock', 'key', 'shield', 'eye', 'thumbs-up', 'award', 'graduation', 'heart', 'star', 'home', 'building', 'wrench', 'hammer', 'brush', 'ruler', 'leaf', 'tree', 'sun', 'droplet', 'flame', 'bolt', 'solar', 'thermometer', 'snowflake', 'car', 'check', 'check-circle', 'info', 'help', 'alert', 'search', 'settings', 'filter', 'grid', 'list', 'sparkle', 'coffee', 'utensils', 'laptop', 'hardware', 'network', 'design'];
+    public const ICONS = ['arrow-up-right', 'arrow-right', 'arrow-left', 'arrow-up', 'arrow-down', 'chevron-right', 'chevron-left', 'chevron-up', 'chevron-down', 'arrow-circle', 'external', 'refresh', 'menu', 'close', 'plus', 'minus', 'phone', 'app', 'mail', 'chat', 'send', 'calendar', 'clock', 'pin', 'map', 'navigation', 'web', 'wifi', 'support', 'shop', 'cart', 'tag', 'euro', 'credit-card', 'gift', 'percent', 'truck', 'package', 'briefcase', 'document', 'download', 'upload', 'print', 'link', 'share', 'image', 'camera', 'video', 'play', 'pause', 'music', 'mic', 'book', 'user', 'people', 'login', 'lock', 'key', 'shield', 'eye', 'thumbs-up', 'award', 'graduation', 'heart', 'star', 'home', 'building', 'wrench', 'hammer', 'brush', 'ruler', 'leaf', 'tree', 'sun', 'droplet', 'flame', 'bolt', 'solar', 'thermometer', 'snowflake', 'car', 'check', 'check-circle', 'info', 'help', 'alert', 'search', 'settings', 'filter', 'grid', 'list', 'sparkle', 'coffee', 'utensils', 'laptop', 'hardware', 'network', 'design', 'facebook', 'instagram', 'whatsapp'];
    /** Das Symbol eines Buttons, wenn keins gewählt ist: der Pfeil, den jeder Button vor v25 hatte. */
    public const BUTTON_DEFAULT_ICON = 'arrow-up-right';
    public const SPACER_SIZES = ['small', 'medium', 'large', 'huge'];
@@ -46,6 +46,47 @@ final class FormRepository
    /** A human needs longer than this to fill in a form; anything faster is a script. */
    public const MIN_SECONDS = 3;
    public const MAX_SECONDS = 86400;
+    /**
+     * Gespeicherte Anfragen je Formular und insgesamt je Stunde (ADR 116). Darüber hinaus wird
+     * nichts mehr gespeichert und nichts verschickt - eine Flut füllt sonst Postfach und
+     * Datenbank, und die Grenze je Absender hilft nicht gegen viele Absender.
+     */
+    public const FORM_RATE_LIMIT = 30;
+    public const GLOBAL_RATE_LIMIT = 120;
+
+    /**
+     * Das Siegel eines Formulars: gebunden an das Formular und an den Zweck, damit ein von einer
+     * Seite geholtes Siegel nicht für jedes Formular gilt (ADR 116).
+     */
+    public static function stamp(string $slug, int $issued, string $secret): string
+    {
+        return hash_hmac('sha256', 'formular|'.$slug.'|'.$issued, $secret);
+    }
+
+    /**
+     * Wer ein Absender ist, für die Grenze je Stunde. Bei IPv6 zählt das /64-Netz: ein einzelner
+     * Anschluss hat davon Milliarden Adressen, mit der vollen Adresse wäre die Grenze wirkungslos.
+     */
+    public static function senderKey(?string $ip, string $secret): string
+    {
+        $ip = (string) $ip;
+        if (str_contains($ip, ':') && false !== ($binary = @inet_pton($ip)) && 16 === \strlen($binary)) {
+            $ip = bin2hex(substr($binary, 0, 8)).'::/64';
+        }
+
+        return hash_hmac('sha256', 'absender|'.$ip, $secret);
+    }
+
+    /** Ob für dieses Formular oder insgesamt in der letzten Stunde schon zu viel ankam. */
+    public function flooded(string $formId): bool
+    {
+        $since = gmdate('Y-m-d H:i:s', time() - 3600);
+        if (self::FORM_RATE_LIMIT <= (int) $this->db->fetchOne('SELECT COUNT(*) FROM form_submission WHERE form_id = ? AND created_at >= ?', [$formId, $since])) {
+            return true;
+        }
+
+        return self::GLOBAL_RATE_LIMIT <= (int) $this->db->fetchOne('SELECT COUNT(*) FROM form_submission WHERE created_at >= ?', [$since]);
+    }

    public function __construct(private Connection $db)
    {
@@ -169,6 +169,27 @@ final class PageRepository
     *
     * @return int the number of pages moved into the bin
     */
+    /**
+     * Ob die Seite - mit $subtree auch eine ihrer Unterseiten - öffentlich ist. Was eine solche
+     * Seite live verändert (Adresse, Papierkorb, Bereiche, Beitragsdaten), darf nur, wer auch
+     * veröffentlichen darf (ADR 116).
+     */
+    public function isLive(string $pageId, bool $subtree = false): bool
+    {
+        $page = $this->db->fetchAssociative('SELECT path, locale, published_revision_id FROM page WHERE id = ? AND website_id = ? AND deleted_at IS NULL', [$pageId, 'default']);
+        if (false === $page) {
+            return false;
+        }
+        if (null !== $page['published_revision_id'] || !$subtree) {
+            return null !== $page['published_revision_id'];
+        }
+
+        return false !== $this->db->fetchOne(
+            'SELECT id FROM page WHERE website_id = ? AND locale = ? AND path LIKE ? AND deleted_at IS NULL AND published_revision_id IS NOT NULL LIMIT 1',
+            ['default', $page['locale'], $page['path'].'/%'],
+        );
+    }
+
    public function trashPage(string $pageId, int $expectedVersion): int
    {
        return $this->db->transactional(function () use ($pageId, $expectedVersion): int {
@@ -279,11 +300,14 @@ final class PageRepository
    {
        $published = [];
        foreach ($this->db->fetchAllAssociative(
-            'SELECT id, path, draft_revision_id, version FROM page WHERE website_id = ? AND deleted_at IS NULL AND publish_at IS NOT NULL AND publish_at <= ? AND draft_revision_id IS NOT NULL AND (published_revision_id IS NULL OR published_revision_id <> draft_revision_id)',
+            // Online geht die Fassung, die beim Planen vorlag (ADR 116) - nicht ein Entwurf, den
+            // danach jemand ohne Recht zum Veröffentlichen gespeichert hat. Planungen aus der Zeit
+            // vor dieser Spalte tragen keine Fassung; für sie bleibt es beim Entwurf.
+            'SELECT id, path, COALESCE(publish_revision_id, draft_revision_id) AS revision, version FROM page WHERE website_id = ? AND deleted_at IS NULL AND publish_at IS NOT NULL AND publish_at <= ? AND COALESCE(publish_revision_id, draft_revision_id) IS NOT NULL AND (published_revision_id IS NULL OR published_revision_id <> COALESCE(publish_revision_id, draft_revision_id))',
            ['default', gmdate('Y-m-d H:i:s')],
        ) as $row) {
            try {
-                $this->publish($row['id'], $row['draft_revision_id'], (int) $row['version']);
+                $this->publish($row['id'], $row['revision'], (int) $row['version']);
            } catch (InvalidPage|InvalidDocument|StaleWrite|\InvalidArgumentException $e) {
                // Eine Seite, deren Fassung heute nicht mehr gilt, bleibt Entwurf - und haelt die
                // anderen nicht auf. Der Grund steht im Protokoll, die Seite behaelt ihren Termin.
@@ -291,7 +315,7 @@ final class PageRepository

                continue;
            }
-            $this->db->executeStatement('UPDATE page SET publish_at = NULL WHERE id = ?', [$row['id']]);
+            $this->db->executeStatement('UPDATE page SET publish_at = NULL, publish_revision_id = NULL WHERE id = ?', [$row['id']]);
            $published[] = $row['path'];
        }

@@ -304,9 +328,12 @@ final class PageRepository
        if ('' !== $when && 1 !== preg_match('/^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}$/D', $when)) {
            throw new InvalidPage('Der Zeitpunkt braucht die Form JJJJ-MM-TT HH:MM.');
        }
-        $changed = $this->db->executeStatement(
-            'UPDATE page SET publish_at = ?, version = version + 1 WHERE id = ? AND version = ?',
-            ['' === $when ? null : str_replace('T', ' ', $when).':00', $pageId, $expectedVersion],
+        // Mit dem Termin wird der jetzige Entwurf festgehalten: genau er geht online.
+        $changed = '' === $when
+            ? $this->db->executeStatement('UPDATE page SET publish_at = NULL, publish_revision_id = NULL, version = version + 1 WHERE id = ? AND version = ?', [$pageId, $expectedVersion])
+            : $this->db->executeStatement(
+                'UPDATE page SET publish_at = ?, publish_revision_id = draft_revision_id, version = version + 1 WHERE id = ? AND version = ?',
+                [str_replace('T', ' ', $when).':00', $pageId, $expectedVersion],
            );
        if (1 !== $changed) {
            throw new StaleWrite('Die Seite wurde inzwischen geändert. Lade die Übersicht neu.');
@@ -33,7 +33,12 @@ final class ConsentController extends AbstractController
            'none' => [],
            default => array_map(static fn (mixed $group): string => (string) $group, (array) $request->request->all('groups')),
        };
-        $response = $this->redirect($this->backTo($request));
+        // consent.js schickt dasselbe Formular im Hintergrund und kennzeichnet das mit dieser
+        // Kopfzeile: dann keine Weiterleitung, nur das Cookie - die Seite bleibt stehen und das
+        // Skript tauscht aus, was jetzt geladen werden darf (ADR 115). Ein fremdes Formular kann
+        // die Kopfzeile nicht setzen; ein fremdes Skript bräuchte dafür eine CORS-Freigabe.
+        $response = '1' === $request->headers->get('X-Kant-Consent') ? new Response(status: Response::HTTP_NO_CONTENT) : $this->redirect($this->backTo($request));
+        $response->headers->set('Cache-Control', 'no-store');
        // Eine Entscheidung trifft nur der eigene Browser auf dieser Website. Ein fremdes Formular,
        // das hierher postet, darf keine Einwilligung eintragen - die Route hat keine Sitzung und
        // damit kein CSRF-Token, also entscheidet die Herkunft der Anfrage.
@@ -97,7 +102,9 @@ final class ConsentController extends AbstractController
        $target = $request->request->getString('back');
        // Nur ein Pfad dieser Website: `//fremd.example` ist protokollrelativ, und `/\fremd.example`
        // lesen Browser genauso.
-        if ('' === $target || 1 !== preg_match('#^/(?![/\\\\])#', $target)) {
+        // Steuerzeichen und Leerraum ebenfalls nicht: Browser entfernen Tabulator und Zeilenumbruch
+        // aus Adressen, aus `/<Tab>/fremd.example` würde so wieder `//fremd.example`.
+        if ('' === $target || 1 !== preg_match('#^/(?![/\\\\])#', $target) || 1 === preg_match('/[\x00-\x20\x7F\\\\]/', $target)) {
            return '/';
        }

@@ -206,6 +206,9 @@ final class EditorController extends AbstractController
        if (!$this->isCsrfTokenValid('pages', $request->request->getString('_csrf_token'))) {
            return $this->back('Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
        }
+        if ($blocked = $this->liveNeedsPublisher($id, false)) {
+            return $blocked;
+        }
        $terms = static function (string $raw): array {
            $names = array_filter(array_map(trim(...), explode(',', $raw)), static fn (string $n): bool => '' !== $n);

@@ -242,6 +245,9 @@ final class EditorController extends AbstractController
        if (!$this->isCsrfTokenValid('pages', $request->request->getString('_csrf_token'))) {
            return $this->back('Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
        }
+        if ($blocked = $this->liveNeedsPublisher($id, false)) {
+            return $blocked;
+        }
        // An empty field means "the standard area"; that is stored as null, not as an address.
        $choice = static fn (string $value): ?string => '' === $value ? null : $value;
        try {
@@ -265,6 +271,9 @@ final class EditorController extends AbstractController
        if (!$this->isCsrfTokenValid('pages', $request->request->getString('_csrf_token'))) {
            return $this->back('Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
        }
+        if ($blocked = $this->liveNeedsPublisher($id, true)) {
+            return $blocked;
+        }
        try {
            $moved = $this->pages->movePage(
                $id,
@@ -282,6 +291,22 @@ final class EditorController extends AbstractController
            : sprintf('%d Adresse(n) geändert. Von den alten Adressen wird dauerhaft weitergeleitet.', $moved), 'success');
    }

+    /**
+     * Ein Redakteur bearbeitet Entwürfe; was eine veröffentlichte Seite sofort verändert, darf
+     * nur, wer veröffentlichen darf (ADR 116): Adresse, Papierkorb, Kopf- und Fußbereich,
+     * Beitragsdaten. Bei Seiten, die nie veröffentlicht waren, bleibt alles wie bisher.
+     */
+    private function liveNeedsPublisher(string $id, bool $subtree): ?Response
+    {
+        if ($this->isGranted('ROLE_PUBLISHER') || !$this->pages->isLive($id, $subtree)) {
+            return null;
+        }
+
+        return $this->back($subtree
+            ? 'Diese Seite oder eine ihrer Unterseiten ist veröffentlicht. Adresse und Papierkorb ändert, wer veröffentlichen darf.'
+            : 'Diese Seite ist veröffentlicht. Diese Angaben wirken sofort öffentlich und ändert deshalb, wer veröffentlichen darf.');
+    }
+
    #[Route('/pages/{id}/schedule', name: 'admin_schedule', methods: ['POST'])]
    public function schedule(Request $request, string $id): Response
    {
@@ -297,7 +322,7 @@ final class EditorController extends AbstractController

        return $this->back('' === trim($request->request->getString('publishAt'))
            ? 'Die geplante Veröffentlichung wurde entfernt.'
-            : 'Die Veröffentlichung ist geplant. Sie erfolgt beim ersten Aufruf der Website nach diesem Zeitpunkt – siehe „Aufgaben“.', 'success');
+            : 'Die Veröffentlichung ist geplant – mit dem Entwurf von jetzt. Spätere Änderungen gehen erst mit erneutem Planen oder Veröffentlichen online. Sie erfolgt beim ersten Aufruf der Website nach diesem Zeitpunkt – siehe „Aufgaben“.', 'success');
    }

    #[Route('/pages/{id}/restore', name: 'admin_restore_page', methods: ['POST'])]
@@ -357,6 +382,9 @@ final class EditorController extends AbstractController
        if (!$this->isCsrfTokenValid('pages', $request->request->getString('_csrf_token'))) {
            return $this->back('Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
        }
+        if ($blocked = $this->liveNeedsPublisher($id, true)) {
+            return $blocked;
+        }
        try {
            $count = $this->pages->trashPage($id, $request->request->getInt('expectedVersion', -1));
        } catch (InvalidPage|StaleWrite $e) {
@@ -46,12 +46,12 @@ final class FormController extends AbstractController
        if (null === $form || null === $page) {
            throw $this->createNotFoundException('Formular oder Seite nicht gefunden.');
        }
-        $senderHash = hash_hmac('sha256', (string) $request->getClientIp(), $this->secret);
+        $senderHash = FormRepository::senderKey($request->getClientIp(), $this->secret);

        // Three quiet checks before the real validation. A caught bot is answered like a success
        // so it learns nothing, but nothing is stored and nothing is sent.
        $silentlyDropped = '' !== trim($request->request->getString('website'))
-            || !$this->timingIsPlausible($request)
+            || !$this->timingIsPlausible($request, $slug)
            || $this->forms->rateLimited($senderHash)
            // Die vierte, freiwillige Pruefung. Sie antwortet wie die drei anderen still mit
            // Erfolg: ein Absender, der erfaehrt, woran er gescheitert ist, versucht es gezielt
@@ -72,6 +72,11 @@ final class FormController extends AbstractController
            // Re-render the page the form sits on, with the entered values and the messages.
            return $this->renderPage($request, $page, $form, $checked, null === $language ? null : ($page['path'] === $this->settings->homePath() ? $language : $language.'/'.$translatedPath));
        }
+        // Kommt gerade für dieses Formular oder insgesamt zu viel an, wird nichts mehr gespeichert -
+        // aber sichtbar, nicht still: ein echter Besucher soll wissen, dass er anrufen muss.
+        if (!$silentlyDropped && $this->forms->flooded($form['id'])) {
+            return $this->renderPage($request, $page, $form, ['errors' => ['_form' => 'Gerade gehen sehr viele Anfragen ein. Bitte versuchen Sie es später erneut oder melden Sie sich telefonisch.'], 'values' => $checked['values']], null === $language ? null : ($page['path'] === $this->settings->homePath() ? $language : $language.'/'.$translatedPath));
+        }
        if (!$silentlyDropped) {
            $submission = $this->forms->store($form['id'], $checked['values'], $checked['consent'], $senderHash);
            if ($this->deliver($form, $checked['values'])) {
@@ -86,10 +91,10 @@ final class FormController extends AbstractController
    }

    /** The signed timestamp makes the age of the form checkable without storing anything. */
-    private function timingIsPlausible(Request $request): bool
+    private function timingIsPlausible(Request $request, string $slug): bool
    {
        $issued = $request->request->getInt('issued');
-        if (!hash_equals(hash_hmac('sha256', (string) $issued, $this->secret), $request->request->getString('issuedSignature'))) {
+        if (!hash_equals(FormRepository::stamp($slug, $issued, $this->secret), $request->request->getString('issuedSignature'))) {
            return false;
        }
        $age = time() - $issued;
@@ -5,6 +5,8 @@ namespace App\Controller;
 use App\Domain\InvalidPage;
 use App\Ops\Installation;
 use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+use Symfony\Component\HttpFoundation\Cookie;
+use Symfony\Component\HttpFoundation\RedirectResponse;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\Response;
 use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
@@ -20,6 +22,10 @@ use Symfony\Component\Routing\Attribute\Route;
 *
 * After the first account exists, every route in this file answers 404 - not because a file was
 * deleted, but because the database says there is an installation.
+ *
+ * Vorher öffnet sich kein Schritt ohne den Installationsschlüssel (ADR 116): Er steht auf der
+ * Abschlussseite von install.php bzw. in var/install.key. Einmal eingegeben, bleibt im Browser
+ * ein Cookie mit einem Nachweis darüber, nur für /install.
 */
 final class InstallController extends AbstractController
 {
@@ -27,10 +33,46 @@ final class InstallController extends AbstractController
    {
    }

-    #[Route('/install', name: 'install', methods: ['GET'], priority: 10)]
-    public function check(): Response
+    /** Der Name des Cookies, das den Installationsschlüssel nachweist. */
+    public const KEY_COOKIE = 'kant_install';
+
+    #[Route('/install/schluessel', name: 'install_key', methods: ['GET', 'POST'], priority: 11)]
+    public function key(Request $request): Response
    {
-        $this->guard();
+        if ($this->installation->isInstalled()) {
+            throw new NotFoundHttpException('Diese Installation ist abgeschlossen.');
+        }
+        $error = null;
+        try {
+            $this->installation->installKey();
+            $given = $request->isMethod('POST') ? $request->request->getString('schluessel') : $request->query->getString('schluessel');
+            if ('' !== $given) {
+                if ($this->installation->acceptsKey($given)) {
+                    // Weiter ohne den Schlüssel in der Adresse: er soll weder im Verlauf noch in
+                    // einem Serverprotokoll als Verweis stehen bleiben.
+                    $response = $this->redirectToRoute('install');
+                    $response->headers->setCookie(Cookie::create(self::KEY_COOKIE, $this->installation->keyProof(), 0, '/install', null, $request->isSecure(), true, false, Cookie::SAMESITE_STRICT));
+
+                    return $response;
+                }
+                $error = 'Dieser Schlüssel passt nicht.';
+            }
+        } catch (\RuntimeException $e) {
+            $error = $e->getMessage();
+        }
+
+        $response = $this->render('install/key.html.twig', ['step' => 1, 'error' => $error, 'keyFile' => Installation::KEY_FILE]);
+        $response->headers->set('Referrer-Policy', 'no-referrer');
+
+        return $response;
+    }
+
+    #[Route('/install', name: 'install', methods: ['GET'], priority: 10)]
+    public function check(Request $request): Response
+    {
+        if ($blocked = $this->guard($request)) {
+            return $blocked;
+        }
        $checks = $this->installation->checks();

        return $this->render('install/check.html.twig', [
@@ -43,7 +85,9 @@ final class InstallController extends AbstractController
    #[Route('/install/datenbank', name: 'install_database', methods: ['GET', 'POST'], priority: 10)]
    public function database(Request $request): Response
    {
-        $this->guard();
+        if ($blocked = $this->guard($request)) {
+            return $blocked;
+        }
        $error = null;
        $driver = $request->request->getString('driver', 'sqlite');
        if ($request->isMethod('POST') && $this->signed($request, 'datenbank')) {
@@ -89,7 +133,9 @@ final class InstallController extends AbstractController
    #[Route('/install/migration', name: 'install_migration', methods: ['GET', 'POST'], priority: 10)]
    public function migration(Request $request): Response
    {
-        $this->guard();
+        if ($blocked = $this->guard($request)) {
+            return $blocked;
+        }
        if (!$this->installation->environmentWritten()) {
            return $this->redirectToRoute('install_database');
        }
@@ -118,7 +164,9 @@ final class InstallController extends AbstractController
    #[Route('/install/website', name: 'install_website', methods: ['GET', 'POST'], priority: 10)]
    public function website(Request $request): Response
    {
-        $this->guard();
+        if ($blocked = $this->guard($request)) {
+            return $blocked;
+        }
        if (!$this->installation->schemaReady()) {
            return $this->redirectToRoute('install_migration');
        }
@@ -150,7 +198,9 @@ final class InstallController extends AbstractController
    #[Route('/install/konto', name: 'install_account', methods: ['GET', 'POST'], priority: 10)]
    public function account(Request $request): Response
    {
-        $this->guard();
+        if ($blocked = $this->guard($request)) {
+            return $blocked;
+        }
        if (!$this->installation->siteReady()) {
            return $this->redirectToRoute('install_website');
        }
@@ -192,11 +242,21 @@ final class InstallController extends AbstractController
        }
    }

-    private function guard(): void
+    /** 404 nach der Installation; davor ohne Schlüsselnachweis zurück zur Eingabe des Schlüssels. */
+    private function guard(Request $request): ?Response
    {
        if ($this->installation->isInstalled()) {
            throw new NotFoundHttpException('Diese Installation ist abgeschlossen.');
        }
+        try {
+            if ($this->installation->acceptsProof($request->cookies->getString(self::KEY_COOKIE))) {
+                return null;
+            }
+        } catch (\RuntimeException) {
+            // Kein Schlüssel lesbar oder schreibbar: die Eingabeseite sagt, woran es liegt.
+        }
+
+        return new RedirectResponse($this->generateUrl('install_key'));
    }

    private function token(string $step): array
@@ -0,0 +1,104 @@
+<?php
+
+namespace App\Controller;
+
+use App\Content\FontLibrary;
+use App\Content\Theme;
+use App\Domain\InvalidPage;
+use App\Ops\SitePackage;
+use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+use Symfony\Component\HttpFoundation\BinaryFileResponse;
+use Symfony\Component\HttpFoundation\File\UploadedFile;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\ResponseHeaderBag;
+use Symfony\Component\Routing\Attribute\Route;
+
+/**
+ * Inhaltspakete exportieren und importieren (ADR 118) - unter System, nur für Administratoren.
+ *
+ * Der Import ersetzt die Inhalte einer laufenden Website. Deshalb: CSRF, ein ausdrückliches
+ * Häkchen, vorher eine Sicherung, während des Imports Wartung. Konten werden nur übernommen,
+ * wenn man das eigens wählt - sonst bleiben Benutzer und Passwörter dieser Website.
+ */
+final class PackageController extends AbstractController
+{
+    public function __construct(private SitePackage $packages, private FontLibrary $fonts, private Theme $theme)
+    {
+    }
+
+    #[Route('/%kant.admin_path%/system/paket/export', name: 'admin_package_export', methods: ['POST'])]
+    public function export(Request $request): Response
+    {
+        $this->denyAccessUnlessGranted('ROLE_ADMIN');
+        if (!$this->isCsrfTokenValid('system', $request->request->getString('_csrf_token'))) {
+            return $this->back('Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
+        }
+        @set_time_limit(0);
+        try {
+            $file = $this->packages->export($request->request->getBoolean('benutzer'));
+        } catch (InvalidPage $e) {
+            return $this->back($e->getMessage());
+        }
+        $response = new BinaryFileResponse($file, headers: ['Content-Type' => 'application/zip', 'X-Content-Type-Options' => 'nosniff', 'Cache-Control' => 'no-store']);
+        $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, basename($file));
+        // Ein Export ist zum Mitnehmen da, nicht zum Liegenlassen: er enthält alle Inhalte.
+        $response->deleteFileAfterSend();
+
+        return $response;
+    }
+
+    #[Route('/%kant.admin_path%/system/paket/import', name: 'admin_package_import', methods: ['POST'])]
+    public function import(Request $request): Response
+    {
+        $this->denyAccessUnlessGranted('ROLE_ADMIN');
+        if (!$this->isCsrfTokenValid('system', $request->request->getString('_csrf_token'))) {
+            return $this->back('Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
+        }
+        if (!$request->request->getBoolean('bestaetigt')) {
+            return $this->back('Bitte bestätige, dass die Inhalte dieser Website ersetzt werden.');
+        }
+        $upload = $request->files->get('paket');
+        $waiting = basename($request->request->getString('wartend'));
+        $temporary = null;
+        if ($upload instanceof UploadedFile) {
+            if (!$upload->isValid()) {
+                return $this->back(\in_array($upload->getError(), [\UPLOAD_ERR_INI_SIZE, \UPLOAD_ERR_FORM_SIZE], true)
+                    ? 'Das Paket ist größer, als das Hosting für einen Upload erlaubt. Bitte per FTP nach var/pakete/ legen – dann erscheint es hier zur Auswahl.'
+                    : 'Das Hochladen ist gescheitert. Bitte erneut versuchen oder das Paket per FTP nach var/pakete/ legen.');
+            }
+            $temporary = $this->packages->directory().'/hochgeladen-'.bin2hex(random_bytes(6)).'.zip';
+            @mkdir($this->packages->directory(), 0o775, true);
+            $upload->move(\dirname($temporary), basename($temporary));
+            $file = $temporary;
+        } elseif ('' !== $waiting && str_ends_with($waiting, '.zip') && is_file($this->packages->directory().'/'.$waiting)) {
+            $file = $this->packages->directory().'/'.$waiting;
+        } else {
+            return $this->back('Bitte ein Paket hochladen oder eines aus var/pakete/ wählen.');
+        }
+
+        @set_time_limit(0);
+        try {
+            $result = $this->packages->import($file, $request->request->getBoolean('benutzer'));
+        } finally {
+            if (null !== $temporary) {
+                @unlink($temporary);
+            }
+        }
+
+        // Das Ergebnis direkt, nicht über eine Weiterleitung: wurden die Konten ersetzt, gilt die
+        // Anmeldung ab der nächsten Anfrage nicht mehr.
+        // Schriften liegen nicht im Paket, sondern auf dem Server dieser Website (public/assets/fonts).
+        // Fehlt eine, die die neue Gestaltung verlangt, sagt die Ergebnisseite, wo man sie holt.
+        $missing = $result['ok'] ? $this->fonts->missing($this->theme->load()) : [];
+
+        return $this->render('admin/package-result.html.twig', ['result' => $result, 'fontsMissing' => $missing]);
+    }
+
+    private function back(string $message): Response
+    {
+        $this->addFlash('error', $message);
+
+        return $this->redirectToRoute('admin_system');
+    }
+}
@@ -326,7 +326,14 @@ final class PageController extends AbstractController
        // Only the header changes with the scroll position; a scrolled value anywhere in it asks
        // for the small script that marks the page as scrolled.
        // Den Nach-oben-Knopf blendet dasselbe Skript ein; ohne es bleibt er dauerhaft sichtbar.
-        $needsScrolled = (isset($areas['header']) && $this->hasScrolled($areas['header'])) || (bool) ($this->settings->load()['scrollTop'] ?? false);
+        // Dasselbe Skript schließt das aufgeklappte Menü nach einer Wahl (ADR 119) - gebraucht nur,
+        // wenn ein aufklappbares Menü auf ein Sprungziel dieser Seite zeigt: Ein Link auf eine
+        // andere Seite lädt neu (die Seiten senden no-store, also stellt „Zurück“ kein offenes
+        // Menü aus dem Seiten-Cache her). So bleibt eine Seite ohne solche Sprünge ohne Skript.
+        $navigation = $this->navigation($path);
+        $here = array_unique([rtrim($request->getPathInfo(), '/') ?: '/', $this->settings->publicPath($path, $this->settings->homePath())]);
+        $needsScrolled = (isset($areas['header']) && $this->hasScrolled($areas['header'])) || (bool) ($this->settings->load()['scrollTop'] ?? false)
+            || [] !== array_filter($this->collapsibleMenuSlots($documents), fn (string $slot): bool => $this->jumpsWithin($navigation[$slot] ?? [], $here));
        $styles = $this->theme->css($theme).$this->menus->buttonCss($theme['buttons']).$this->scrollTopStyles($this->settings->load(), $theme).$this->consent->styles($theme).$this->styles->compileDocument($page['document']).$this->code->compileDocument($page['document']);
        foreach ([...array_values($areas), ...array_values($sections)] as $extra) {
            $styles .= $this->styles->compileDocument($extra).$this->code->compileDocument($extra);
@@ -371,12 +378,18 @@ final class PageController extends AbstractController
        // Vorlage holt die Liste von hier, statt sie durch jede Einbindung zu reichen.
        $request->attributes->set('kant_alternates', $alternates);
        $canonical = null === $adresse ? null : $adresse.(null !== $blaettern && $blaettern['page'] > 1 ? '?seite='.$blaettern['page'] : '');
+        // Steht eine Einwilligung aus - Hinweis offen oder ein eingebetteter Inhalt wartet -, kommt
+        // consent.js dazu: Es speichert die Entscheidung ohne Neuladen. Ohne Skript bleibt das
+        // Formular mit Weiterleitung.
+        $embeds = $this->embedState($request, $page['document'], ...array_values($areas), ...array_values($sections));
+        $needsConsent = $embeds['blocked'] || $this->consent->needsBanner($request);
        $response = $this->render('page.html.twig', [
+            'needsConsent' => $needsConsent,
            'page' => $page,
            'canonical' => $canonical,
            'alternates' => $alternates,
            'pagination' => null === $blaettern || null === $adresse ? null : ['page' => $blaettern['page'], 'pages' => $blaettern['pages'], 'base' => $adresse],
-            'navigation' => $this->navigation($path),
+            'navigation' => $navigation,
            'postLists' => $postLists,
            // Ohne Beiträge gibt es keinen Feed, auf den der Kopf verweisen könnte.
            'hasPosts' => $this->posts->anyPublished(),
@@ -429,8 +442,8 @@ final class PageController extends AbstractController
        // Die Pruefung braucht ein Skript von Cloudflare und einen Rahmen dafuer. Beides wird nur
        // dort erlaubt, wo tatsaechlich ein Formular steht - nicht auf jeder Seite der Website.
        $mitTurnstile = $this->turnstile->isActive() && (bool) array_filter($documents, fn (array $doc): bool => $this->hasType($doc, 'form'));
-        $wantsScript = ($mitTurnstile || $needsTabs || $needsFormScript || [] !== $pluginAssets['scripts'] || [] !== $areaScripts || $needsSlider || $needsMotion || $needsScrolled || $needsZoom || $needsDocument || [] !== $this->code->scriptsOf($page['document']));
-        $frames = $this->frameHosts($request, $page['document'], ...array_values($areas), ...array_values($sections));
+        $wantsScript = ($mitTurnstile || $needsTabs || $needsFormScript || [] !== $pluginAssets['scripts'] || [] !== $areaScripts || $needsSlider || $needsMotion || $needsScrolled || $needsZoom || $needsDocument || $needsConsent || [] !== $this->code->scriptsOf($page['document']));
+        $frames = $embeds['hosts'];
        if ($mitTurnstile) {
            $frames[] = 'challenges.cloudflare.com';
        }
@@ -453,9 +466,9 @@ final class PageController extends AbstractController
     * The generated stylesheet is inline for speed, so it is allowed by its own hash rather than
     * by 'unsafe-inline' – any other inline style, injected or not, stays blocked.
     *
-     * @param list<string> $frameHosts Hosts of embeds that are actually rendered on this response.
-     *                                 Nothing is added to the policy for an embed still waiting
-     *                                 for consent.
+     * @param list<string> $frameHosts Hosts of the embeds on this page, also of those still
+     *                                 waiting for consent (ADR 115: consent.js inserts them
+     *                                 without a reload, and a policy cannot change afterwards)
     * @param bool         $frameSelf  whether the page may frame its own PDFs (the viewer)
     */
    private function shell(Response $response, bool $allowScript = false, string $styles = '', array $frameHosts = [], bool $frameSelf = false): Response
@@ -526,7 +539,7 @@ final class PageController extends AbstractController
                        'errors' => [], 'values' => [],
                        'blockId' => $block['id'], 'page' => $page,
                        'issued' => $issued,
-                        'issuedSignature' => hash_hmac('sha256', (string) $issued, $this->secret),
+                        'issuedSignature' => FormRepository::stamp($slug, $issued, $this->secret),
                        // Leer, solange die Pruefung aus ist - dann steht auch kein Widget da.
                        'turnstileKey' => $this->turnstile->isActive() ? $this->turnstile->siteKey() : '',
                    ];
@@ -768,6 +781,50 @@ final class PageController extends AbstractController
    }

    /** Whether any block carries values for the scrolled page (see StyleSchema::scrollable). */
+    /**
+     * Die Menüplätze (header, footer …) der Menüs, die als Knopf aufklappen: Burger oder waagerecht
+     * mit Zusammenklappen.
+     *
+     * @return list<string>
+     */
+    private function collapsibleMenuSlots(array $documents): array
+    {
+        $slots = [];
+        $walk = function (array $blocks) use (&$walk, &$slots): void {
+            foreach ($blocks as $block) {
+                if ('menu' === ($block['type'] ?? null)) {
+                    $layout = $block['props']['layout'] ?? 'horizontal';
+                    if ('burger' === $layout || ('horizontal' === $layout && 'never' !== ($block['props']['collapse'] ?? 'tablet'))) {
+                        $slots[] = (string) ($block['props']['slot'] ?? 'header');
+                    }
+                }
+                $walk($block['children'] ?? []);
+            }
+        };
+        foreach ($documents as $document) {
+            $walk($document['blocks'] ?? []);
+        }
+
+        return array_values(array_unique($slots));
+    }
+
+    /** Ob ein Link des Menüs zu einem Sprungziel auf dieser Seite führt (#kontakt, /#kontakt auf der Startseite). @param list<string> $here */
+    private function jumpsWithin(array $links, array $here): bool
+    {
+        foreach ($links as $link) {
+            $href = (string) ($link['href'] ?? '');
+            $hash = strpos($href, '#');
+            if (false !== $hash && (0 === $hash || \in_array(rtrim(substr($href, 0, $hash), '/') ?: '/', $here, true))) {
+                return true;
+            }
+            if ($this->jumpsWithin($link['children'] ?? [], $here)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
    private function hasScrolled(array $document): bool
    {
        $walk = function (array $blocks) use (&$walk): bool {
@@ -1079,23 +1136,27 @@ final class PageController extends AbstractController
    }

    /**
-     * The hosts of embeds that may load on this request.
+     * The hosts of all embeds on this page, and whether one of them still waits for consent.
     *
-     * An embed whose group is not granted contributes nothing: its host must not appear in the
-     * policy, because the frame is not rendered either.
+     * Seit ADR 115 steht der Host auch dann in frame-src, wenn die Gruppe noch nicht erlaubt ist:
+     * Die Richtlinie einer Seite steht beim Laden fest, und consent.js setzt den Rahmen nach der
+     * Einwilligung ohne Neuladen ein. Die Erlaubnis lädt nichts; die Adresse des Inhalts steht
+     * weiterhin erst nach der Einwilligung im HTML.
     *
-     * @return list<string>
+     * @return array{hosts: list<string>, blocked: bool}
     */
-    private function frameHosts(Request $request, array ...$documents): array
+    private function embedState(Request $request, array ...$documents): array
    {
        $hosts = [];
-        $walk = function (array $blocks) use (&$walk, &$hosts, $request): void {
+        $blocked = false;
+        $walk = function (array $blocks) use (&$walk, &$hosts, &$blocked, $request): void {
            foreach ($blocks as $block) {
-                if ('embed' === ($block['type'] ?? null) && $this->consent->granted($request, $block['props']['group'] ?? '')) {
+                if ('embed' === ($block['type'] ?? null) && '' !== ($block['props']['url'] ?? '')) {
                    $host = parse_url($block['props']['url'] ?? '', PHP_URL_HOST);
                    if (is_string($host)) {
                        $hosts[$host] = true;
                    }
+                    $blocked = $blocked || !$this->consent->granted($request, $block['props']['group'] ?? '');
                }
                $walk($block['children'] ?? []);
            }
@@ -1104,7 +1165,7 @@ final class PageController extends AbstractController
            $walk($document['blocks'] ?? []);
        }

-        return array_keys($hosts);
+        return ['hosts' => array_keys($hosts), 'blocked' => $blocked];
    }

    /**
@@ -77,7 +77,7 @@ final class PartialController extends AbstractController
                $request->request->getString('slug') ?: $this->slugify($name),
                $name,
                // A shared area starts with one empty section, so there is something to click on.
-                ['schemaVersion' => 11, 'title' => '' === $name ? 'Bereich' : $name, 'description' => 'Wird an jeder Stelle gezeigt, die ihn einbindet.', 'blocks' => [
+                ['schemaVersion' => DocumentValidator::SCHEMA_VERSION, 'title' => '' === $name ? 'Bereich' : $name, 'description' => 'Wird an jeder Stelle gezeigt, die ihn einbindet.', 'blocks' => [
                    ['id' => 'b_'.bin2hex(random_bytes(8)), 'type' => 'section', 'layout' => ['tone' => 'paper', 'width' => 'normal'], 'children' => []],
                ]],
            );
@@ -11,6 +11,7 @@ use App\Ops\Backup;
 use App\Ops\Environment;
 use App\Ops\Installation;
 use App\Ops\OriginCheck;
+use App\Ops\SitePackage;
 use App\Ops\Updater;
 use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
 use Symfony\Component\HttpFoundation\JsonResponse;
@@ -28,7 +29,7 @@ use Symfony\Component\Routing\Attribute\Route;
 */
 final class SystemController extends AbstractController
 {
-    public function __construct(private Updater $updater, private Backup $backup, private ArchiveUpdate $archive, private Installation $installation, private string $adminPath, private string $databaseUrl, private string $mediaDirectory, private string $projectDir, private string $siteOrigin, private OriginCheck $originCheck, private HttpKernelInterface $kernel, private PageRepository $pages, private SiteSettings $settings)
+    public function __construct(private Updater $updater, private Backup $backup, private ArchiveUpdate $archive, private Installation $installation, private string $adminPath, private string $databaseUrl, private string $mediaDirectory, private string $projectDir, private string $siteOrigin, private OriginCheck $originCheck, private HttpKernelInterface $kernel, private PageRepository $pages, private SiteSettings $settings, private SitePackage $packages)
    {
    }

@@ -47,6 +48,9 @@ final class SystemController extends AbstractController
            'asked' => $request->query->getBoolean('pruefen'),
            'steps' => $request->getSession()->remove('update_steps') ?: [],
            'backups' => $this->backup->all(),
+            // Inhaltspakete (ADR 118): die per FTP abgelegten und die Grenze für Uploads.
+            'packages' => $this->packages->waiting(),
+            'uploadLimit' => $this->uploadLimit(),
            'adminPath' => $this->adminPath,
            // Der Weg ohne Git: das Releasearchiv. Auf geteiltem Hosting ist das der einzige.
            'archiveVersion' => $request->query->getBoolean('pruefen') ? $this->archive->updateAvailable() : null,
@@ -497,6 +501,23 @@ final class SystemController extends AbstractController
        return new Response($this->originCheck->token(), 200, ['Content-Type' => 'text/plain; charset=UTF-8', 'Cache-Control' => 'no-store', 'X-Robots-Tag' => 'noindex']);
    }

+    /** Die kleinere der beiden PHP-Grenzen, die einen Upload begrenzen - so, wie sie in der php.ini steht. */
+    private function uploadLimit(): string
+    {
+        $bytes = static function (string $value): int {
+            $value = trim($value);
+            $number = (int) $value;
+
+            return match (strtolower(substr($value, -1))) {
+                'g' => $number * 1024 ** 3, 'm' => $number * 1024 ** 2, 'k' => $number * 1024, default => $number,
+            };
+        };
+        $limits = array_filter([$bytes((string) ini_get('upload_max_filesize')), $bytes((string) ini_get('post_max_size'))]);
+        $min = [] === $limits ? 0 : min($limits);
+
+        return 0 === $min ? 'unbegrenzt' : number_format($min / 1048576, 0, ',', '.').' MB';
+    }
+
    private function back(string $message, string $type = 'error'): Response
    {
        $this->addFlash($type, $message);
@@ -3,6 +3,7 @@
 namespace App\EventSubscriber;

 use App\Ops\Installation;
+use App\Ops\Protection;
 use Symfony\Component\EventDispatcher\EventSubscriberInterface;
 use Symfony\Component\HttpFoundation\RedirectResponse;
 use Symfony\Component\HttpKernel\Event\RequestEvent;
@@ -36,6 +37,8 @@ final class InstallSubscriber implements EventSubscriberInterface

    public function onRequest(RequestEvent $event): void
    {
+        // Fehlende Sperrdateien nachtragen (var/, vendor/, Projektstamm) - einmal je Prozess.
+        Protection::ensure($this->projectDir);
        if (!$event->isMainRequest() || is_file($this->projectDir.'/'.self::MARKER)) {
            return;
        }
@@ -155,6 +155,12 @@ final class ArchiveUpdate
            return ['ok' => false, 'steps' => $schritte];
        }
        $ziel = $version ?? $neueste['version'];
+        // Die Fassung landet in Adresse und Pfaden; nur die Form 1.2.3 ist zulässig (ADR 116).
+        if (1 !== preg_match('/^\d{1,4}\.\d{1,5}\.\d{1,6}$/D', $ziel)) {
+            $melden($schritte, 'Fassung ermitteln', false, 'Die gewünschte Fassung hat nicht die Form 1.2.3.');
+
+            return ['ok' => false, 'steps' => $schritte];
+        }
        $melden($schritte, 'Fassung ermitteln', true, sprintf('Installiert: %s, verfügbar: %s.', $this->updater->version(), $neueste['version']));
        if (version_compare($ziel, $this->updater->version(), '<=')) {
            $melden($schritte, 'Nichts zu tun', true, 'Diese Installation ist bereits auf dem neuesten Stand.');
@@ -37,6 +37,14 @@ final class Installation
    /** Longer than a person needs for a form, short enough that a stale tab stops working. */
    public const TOKEN_LIFETIME = 7200;

+    /**
+     * Der Installationsschlüssel (ADR 116). Ohne ihn öffnet sich kein Schritt des Installers: wer
+     * eine frisch entpackte Installation zuerst aufruft, soll sie nicht übernehmen können.
+     * install.php legt ihn an und zeigt ihn nur dem Browser, der entpackt hat; wer per FTP
+     * entpackt, findet ihn in dieser Datei. Mit dem ersten Konto wird er gelöscht.
+     */
+    public const KEY_FILE = 'var/install.key';
+
    public function __construct(
        private Connection $db,
        private PageRepository $pages,
@@ -357,16 +365,73 @@ final class Installation
        if (!hash_equals($password, $repeated)) {
            throw new InvalidPage('Die beiden Passwörter stimmen nicht überein.');
        }
+        $user = new CmsUser(bin2hex(random_bytes(16)), $username, '', ['ROLE_ADMIN']);
+        $hash = $this->hasher->hashPassword($user, $password);
+        // Prüfen und Anlegen in einer Transaktion: zwei gleichzeitige Absendungen sollen nicht zwei
+        // erste Konten ergeben.
+        $this->db->transactional(function () use ($user, $username, $hash): void {
            if ($this->isInstalled()) {
                throw new InvalidPage('Es gibt bereits ein Konto. Die Installation ist damit abgeschlossen.');
            }
-        $user = new CmsUser(bin2hex(random_bytes(16)), $username, '', ['ROLE_ADMIN']);
            $this->db->insert('cms_user', [
                'id' => $user->id,
                'username' => $username,
-            'password_hash' => $this->hasher->hashPassword($user, $password),
+                'password_hash' => $hash,
                'roles' => json_encode($user->getRoles(), JSON_THROW_ON_ERROR),
            ]);
+        });
+        // Der Schlüssel hat seine Arbeit getan; liegen bleiben soll er nicht.
+        @unlink($this->root.'/'.self::KEY_FILE);
+    }
+
+    /**
+     * Der Schlüssel dieser Installation; beim ersten Aufruf angelegt, wenn install.php es nicht
+     * schon getan hat. 128 Bit aus random_bytes - raten lohnt nicht, eine Sperre braucht es nicht.
+     */
+    public function installKey(): string
+    {
+        $file = $this->root.'/'.self::KEY_FILE;
+        $key = is_file($file) ? trim((string) file_get_contents($file)) : '';
+        if (1 === preg_match('/^[a-f0-9]{32}$/D', $key)) {
+            return $key;
+        }
+        if (!is_dir(\dirname($file)) && !@mkdir(\dirname($file), 0o775, true) && !is_dir(\dirname($file))) {
+            throw new \RuntimeException('var/ ist nicht beschreibbar; ohne Installationsschlüssel geht es nicht weiter.');
+        }
+        $key = bin2hex(random_bytes(16));
+        // x: nur anlegen, wenn es die Datei noch nicht gibt - zwei gleichzeitige erste Aufrufe
+        // sollen sich nicht gegenseitig den Schlüssel überschreiben.
+        $handle = @fopen($file, 'x');
+        if (false === $handle) {
+            $existing = trim((string) @file_get_contents($file));
+            if (1 === preg_match('/^[a-f0-9]{32}$/D', $existing)) {
+                return $existing;
+            }
+            throw new \RuntimeException('Der Installationsschlüssel ließ sich nicht schreiben ('.self::KEY_FILE.').');
+        }
+        fwrite($handle, $key.'
+');
+        fclose($handle);
+        @chmod($file, 0o600);
+
+        return $key;
+    }
+
+    /** Ob die Eingabe der Schlüssel ist - Leerzeichen und Großbuchstaben aus dem Abtippen zählen nicht. */
+    public function acceptsKey(string $given): bool
+    {
+        return hash_equals($this->installKey(), strtolower(preg_replace('/\s+/', '', $given) ?? ''));
+    }
+
+    /** Was als Cookie im Browser bleibt: nicht der Schlüssel selbst, sondern ein Nachweis über ihn. */
+    public function keyProof(): string
+    {
+        return hash_hmac('sha256', 'installer', $this->installKey());
+    }
+
+    public function acceptsProof(string $proof): bool
+    {
+        return '' !== $proof && hash_equals($this->keyProof(), $proof);
    }

    /**
@@ -374,9 +439,8 @@ final class Installation
     *
     * The session cookie of this application is scoped to `/admin`, so the installer has no
     * session - and it should not get one for six screens. The signature ties a form to a step and
-     * to a point in time. It is not protection against somebody who can reach the installer: that
-     * protection is that the installer stops existing after the first account, which is why the
-     * last screen says to install right after uploading.
+     * to a point in time. Wer überhaupt an den Installer darf, entscheidet seit ADR 116 der
+     * Installationsschlüssel; die Unterschrift bindet nur das Formular an seinen Schritt.
     */
    public function sign(string $step, int $issued): string
    {
@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Ops;
+
+/**
+ * Sperrdateien, die dafür sorgen, dass nichts außer public/ über das Netz erreichbar ist - auch
+ * wenn die Domain versehentlich auf den Projektordner zeigt (ADR 116).
+ *
+ * Die meisten liegen im Release (bin/, config/, src/ …, vendor/ und der Projektstamm). Zwei
+ * entstehen erst auf dem Server: var/ gibt es im Archiv nicht, und die Datei im Projektstamm soll
+ * auch eine Installation bekommen, die von einer Fassung vor 1.30.0 aktualisiert wurde - deren
+ * Updater kannte sie noch nicht. Angelegt wird nur, was fehlt; eine eigene .htaccess des Betreibers
+ * im Projektstamm bleibt unberührt.
+ */
+final class Protection
+{
+    private static bool $checked = false;
+
+    public static function ensure(string $root): void
+    {
+        if (self::$checked) {
+            return;
+        }
+        self::$checked = true;
+        $sperren = $root.'/config/schutz/sperren.htaccess';
+        $stamm = $root.'/config/schutz/stamm.htaccess';
+        foreach ([$root.'/var/.htaccess' => $sperren, $root.'/vendor/.htaccess' => $sperren, $root.'/.htaccess' => $stamm] as $ziel => $vorlage) {
+            if (!is_file($ziel) && is_dir(\dirname($ziel)) && is_file($vorlage)) {
+                @copy($vorlage, $ziel);
+            }
+        }
+    }
+
+    /** Für Tests: die nächste Anfrage prüft wieder. */
+    public static function reset(): void
+    {
+        self::$checked = false;
+    }
+}
@@ -0,0 +1,486 @@
+<?php
+
+namespace App\Ops;
+
+use App\Content\DocumentValidator;
+use App\Domain\InvalidDocument;
+use App\Domain\InvalidPage;
+use Doctrine\DBAL\Connection;
+
+/**
+ * Inhalte einer Website als Paket - exportieren und in eine andere Installation importieren
+ * (ADR 118).
+ *
+ * Anlass: Eine lokal aufgebaute Website wurde bisher als ganze Datenbankdatei hochgeladen. Damit
+ * kamen auch die Konten mit, und nach jeder Änderung galt live ein neues Passwort; was nur live
+ * entstanden war (Anfragen, Statistik), war weg. Ein Paket trägt deshalb nur Inhalte: Seiten mit
+ * allen Fassungen, Bereiche, Menüs, Medien, Formulare, Weiterleitungen, Kategorien, Übersetzungen,
+ * Gestaltung und Einstellungen. Konten nur, wenn man sie ausdrücklich mitnimmt - und beim Import
+ * werden sie nur übernommen, wenn man das ausdrücklich wählt.
+ *
+ * Das Format ist Zip mit JSON statt einer SQLite-Datei: So geht ein Paket von SQLite nach MySQL
+ * und zurück, und der Import prüft jede Zeile, bevor er schreibt.
+ */
+final class SitePackage
+{
+    public const FORMAT = 1;
+    public const MANIFEST = 'paket.json';
+    public const DATA = 'inhalt.json';
+    public const MEDIA = 'medien/';
+
+    /** Was ersetzt wird, in der Reihenfolge des Einfügens (revision gehört zu page). */
+    public const CONTENT_TABLES = ['page', 'revision', 'partial', 'menu', 'media', 'document', 'form', 'redirect', 'term', 'page_term', 'page_translation'];
+
+    /** Einstellungen dieser Installation, die ein Paket nie überschreibt: Zugangsdaten zu Diensten. */
+    public const KEEP_SETTINGS = ['turnstile', 'turnstileSiteKey', 'turnstileSecret'];
+
+    /** Dateinamen im Medienordner: Bildvarianten, PDFs, erzeugte Seitensymbole. Sonst nichts. */
+    public const MEDIA_NAME = '/^(?:[a-f0-9]{32}(?:-\d{1,5})?\.(?:webp|pdf)|favicon-\d{1,4}\.png)$/D';
+
+    private const MAX_FILES = 5000;
+    private const MAX_FILE_BYTES = 64 * 1024 * 1024;
+    private const MAX_TOTAL_BYTES = 1024 * 1024 * 1024;
+    private const MAX_DATA_BYTES = 64 * 1024 * 1024;
+
+    public function __construct(
+        private Connection $db,
+        private DocumentValidator $validator,
+        private Backup $backup,
+        private Updater $updater,
+        private string $root,
+        private string $mediaDirectory,
+    ) {
+    }
+
+    /** Wohin Pakete gehören, die per FTP kommen, und wo Exporte entstehen. */
+    public function directory(): string
+    {
+        return $this->root.'/var/pakete';
+    }
+
+    /**
+     * Schreibt ein Paket und gibt seinen Pfad zurück.
+     *
+     * @throws InvalidPage
+     */
+    public function export(bool $withUsers = false, ?string $target = null): string
+    {
+        if (!class_exists(\ZipArchive::class)) {
+            throw new InvalidPage('Ohne die PHP-Erweiterung zip lässt sich kein Paket schreiben.');
+        }
+        $tables = [];
+        foreach (self::CONTENT_TABLES as $table) {
+            $tables[$table] = $this->rows($table);
+        }
+        $website = $this->db->fetchAssociative('SELECT id, name, default_locale, theme, settings FROM website WHERE id = ?', ['default']);
+        if (false === $website) {
+            throw new InvalidPage('Diese Installation hat noch keine Website.');
+        }
+        // Zugangsdaten zu Diensten bleiben, wo sie sind - auch im Paket stehen sie nicht.
+        $settings = json_decode((string) ($website['settings'] ?? '{}'), true) ?: [];
+        foreach (self::KEEP_SETTINGS as $key) {
+            unset($settings[$key]);
+        }
+        $website['settings'] = json_encode($settings, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
+        $tables['website'] = [$website];
+        if ($withUsers) {
+            $tables['cms_user'] = $this->rows('cms_user');
+        }
+        $data = json_encode(['tabellen' => $tables], JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
+
+        $files = [];
+        foreach (scandir($this->mediaDirectory) ?: [] as $name) {
+            if (1 === preg_match(self::MEDIA_NAME, $name) && is_file($this->mediaDirectory.'/'.$name)) {
+                $files[] = $name;
+            }
+        }
+        $manifest = [
+            'format' => self::FORMAT,
+            'art' => 'KantSites-Inhaltspaket',
+            'fassung' => $this->backup->version(),
+            'erstellt' => gmdate('c'),
+            'website' => (string) $website['name'],
+            'benutzer' => $withUsers,
+            'inhalt' => array_map('count', $tables),
+            'medien' => count($files),
+            'sha256' => hash('sha256', $data),
+        ];
+
+        $target ??= $this->directory().'/'.$this->fileName((string) $website['name']);
+        if (!is_dir(\dirname($target)) && !@mkdir(\dirname($target), 0o775, true)) {
+            throw new InvalidPage('Der Ordner für Pakete ließ sich nicht anlegen. Schreibrechte auf var/ prüfen.');
+        }
+        $zip = new \ZipArchive();
+        if (true !== $zip->open($target, \ZipArchive::CREATE | \ZipArchive::OVERWRITE)) {
+            throw new InvalidPage('Das Paket ließ sich nicht anlegen.');
+        }
+        $zip->addFromString(self::MANIFEST, json_encode($manifest, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES));
+        $zip->addFromString(self::DATA, $data);
+        foreach ($files as $name) {
+            $zip->addFile($this->mediaDirectory.'/'.$name, self::MEDIA.$name);
+        }
+        $zip->close();
+
+        return $target;
+    }
+
+    /** Pakete, die per FTP in var/pakete liegen - neueste zuerst. @return list<array{name: string, bytes: int, manifest: ?array}> */
+    public function waiting(): array
+    {
+        $found = [];
+        foreach (glob($this->directory().'/*.zip') ?: [] as $file) {
+            try {
+                $manifest = $this->inspect($file);
+            } catch (InvalidPage) {
+                $manifest = null;
+            }
+            $found[] = ['name' => basename($file), 'bytes' => (int) filesize($file), 'manifest' => $manifest, 'time' => (int) filemtime($file)];
+        }
+        usort($found, static fn (array $a, array $b): int => $b['time'] <=> $a['time']);
+
+        return $found;
+    }
+
+    /**
+     * Prüft ein Paket, ohne etwas zu schreiben, und gibt sein Manifest zurück.
+     *
+     * @throws InvalidPage
+     */
+    public function inspect(string $file): array
+    {
+        $zip = $this->open($file);
+        try {
+            return $this->checkedManifest($zip);
+        } finally {
+            $zip->close();
+        }
+    }
+
+    /**
+     * Spielt ein Paket ein.
+     *
+     * @return array{ok: bool, steps: list<array{step: string, ok: bool, detail: string}>, users: bool}
+     */
+    public function import(string $file, bool $withUsers = false): array
+    {
+        $steps = [];
+        $step = static function (string $name, bool $ok, string $detail) use (&$steps): bool {
+            $steps[] = ['step' => $name, 'ok' => $ok, 'detail' => $detail];
+
+            return $ok;
+        };
+        $fail = static function () use (&$steps): array {
+            return ['ok' => false, 'steps' => $steps, 'users' => false];
+        };
+
+        try {
+            $zip = $this->open($file);
+        } catch (InvalidPage $e) {
+            $step('Paket öffnen', false, $e->getMessage());
+
+            return $fail();
+        }
+        try {
+            try {
+                $manifest = $this->checkedManifest($zip);
+                $step('Paket prüfen', true, sprintf('„%s“ vom %s, Fassung %s, %d Seite(n), %d Mediendatei(en).', $manifest['website'], substr((string) $manifest['erstellt'], 0, 10), $manifest['fassung'], (int) ($manifest['inhalt']['page'] ?? 0), (int) $manifest['medien']));
+                $tables = $this->checkedData($zip, $manifest);
+                $this->validateDocuments($tables);
+                $step('Inhalte prüfen', true, 'Alle Tabellen bekannt, alle Seiten- und Bereichsdokumente gültig.');
+            } catch (InvalidPage|InvalidDocument $e) {
+                $step('Paket prüfen', false, $e->getMessage());
+
+                return $fail();
+            }
+            if ($withUsers && [] === ($tables['cms_user'] ?? [])) {
+                $step('Konten', false, 'Das Paket enthält keine Konten. Ohne Häkchen bei „Konten übernehmen“ bleiben die Konten dieser Website.');
+
+                return $fail();
+            }
+
+            try {
+                $safety = $this->backup->create('vor Import');
+                $step('Aktuellen Stand sichern', true, $safety['name'].' – damit lässt sich der Import zurücknehmen (cms:restore).');
+            } catch (\Throwable $e) {
+                $step('Aktuellen Stand sichern', false, $e->getMessage().' Ohne Sicherung wird nicht importiert.');
+
+                return $fail();
+            }
+
+            $this->updater->maintenance(true);
+            try {
+                $media = $this->extractMedia($zip);
+                $this->write($tables, $withUsers);
+                $step('Inhalte ersetzen', true, $this->summary($tables, $withUsers));
+                $moved = $this->replaceMedia($media);
+                $step('Medien ersetzen', true, sprintf('%d Datei(en) übernommen.', $moved));
+            } catch (\Throwable $e) {
+                $step('Inhalte ersetzen', false, $e->getMessage().' Die Datenbank blieb unverändert; die Sicherung liegt bereit.');
+
+                return $fail();
+            } finally {
+                $this->updater->maintenance(false);
+                if (isset($media)) {
+                    $this->remove($media);
+                }
+            }
+        } finally {
+            $zip->close();
+        }
+
+        return ['ok' => true, 'steps' => $steps, 'users' => $withUsers];
+    }
+
+    /** @throws InvalidPage */
+    private function open(string $file): \ZipArchive
+    {
+        if (!class_exists(\ZipArchive::class)) {
+            throw new InvalidPage('Ohne die PHP-Erweiterung zip lässt sich kein Paket lesen.');
+        }
+        $zip = new \ZipArchive();
+        if (!is_file($file) || true !== $zip->open($file, \ZipArchive::RDONLY)) {
+            throw new InvalidPage('Das ist kein lesbares Zip-Archiv.');
+        }
+        // Jeder Eintrag wird geprüft, bevor irgendetwas gelesen wird: nur die drei bekannten
+        // Arten, keine Pfade nach oben, keine übergroßen Dateien (Zip-Bombe).
+        if ($zip->numFiles > self::MAX_FILES + 2) {
+            $zip->close();
+            throw new InvalidPage('Das Paket enthält zu viele Dateien.');
+        }
+        $total = 0;
+        for ($i = 0; $i < $zip->numFiles; ++$i) {
+            $stat = $zip->statIndex($i);
+            $name = (string) ($stat['name'] ?? '');
+            $total += (int) ($stat['size'] ?? 0);
+            $known = self::MANIFEST === $name || self::DATA === $name || self::MEDIA === $name
+                || (str_starts_with($name, self::MEDIA) && 1 === preg_match(self::MEDIA_NAME, substr($name, \strlen(self::MEDIA))));
+            if (!$known || (int) ($stat['size'] ?? 0) > self::MAX_FILE_BYTES) {
+                $zip->close();
+                throw new InvalidPage(sprintf('„%s“ gehört nicht in ein Inhaltspaket. Es wird nicht eingespielt.', mb_substr($name, 0, 80)));
+            }
+        }
+        if ($total > self::MAX_TOTAL_BYTES) {
+            $zip->close();
+            throw new InvalidPage('Das Paket ist entpackt größer als 1 GB.');
+        }
+
+        return $zip;
+    }
+
+    /** @throws InvalidPage */
+    private function checkedManifest(\ZipArchive $zip): array
+    {
+        $raw = $zip->getFromName(self::MANIFEST);
+        $manifest = false === $raw ? null : json_decode($raw, true);
+        if (!\is_array($manifest) || ($manifest['art'] ?? null) !== 'KantSites-Inhaltspaket' || ($manifest['format'] ?? null) !== self::FORMAT) {
+            throw new InvalidPage('Das ist kein KantSites-Inhaltspaket (paket.json fehlt oder passt nicht).');
+        }
+        if (1 !== preg_match('/^\d+\.\d+\.\d+$/D', (string) ($manifest['fassung'] ?? ''))) {
+            throw new InvalidPage('Im Paket fehlt die Fassung, aus der es stammt.');
+        }
+        // Ein Paket aus einer neueren Fassung kann Inhalte tragen, die dieser Kern nicht kennt.
+        if (version_compare((string) $manifest['fassung'], $this->backup->version(), '>')) {
+            throw new InvalidPage(sprintf('Das Paket stammt aus Fassung %s, installiert ist %s. Erst diese Website aktualisieren.', $manifest['fassung'], $this->backup->version()));
+        }
+
+        return $manifest;
+    }
+
+    /**
+     * @return array<string, list<array<string, mixed>>>
+     *
+     * @throws InvalidPage
+     */
+    private function checkedData(\ZipArchive $zip, array $manifest): array
+    {
+        $stat = $zip->statName(self::DATA);
+        if (false === $stat || $stat['size'] > self::MAX_DATA_BYTES) {
+            throw new InvalidPage('inhalt.json fehlt oder ist zu groß.');
+        }
+        $raw = (string) $zip->getFromName(self::DATA);
+        if (!hash_equals((string) ($manifest['sha256'] ?? ''), hash('sha256', $raw))) {
+            throw new InvalidPage('Die Prüfsumme von inhalt.json stimmt nicht. Das Paket ist beschädigt oder verändert.');
+        }
+        $data = json_decode($raw, true, 32);
+        $tables = \is_array($data) ? ($data['tabellen'] ?? null) : null;
+        if (!\is_array($tables)) {
+            throw new InvalidPage('inhalt.json ist nicht lesbar.');
+        }
+        $allowed = [...self::CONTENT_TABLES, 'website', 'cms_user'];
+        foreach ($tables as $table => $rows) {
+            if (!\in_array($table, $allowed, true) || !\is_array($rows) || !array_is_list($rows)) {
+                throw new InvalidPage(sprintf('Die Tabelle „%s“ gehört nicht in ein Inhaltspaket.', mb_substr((string) $table, 0, 40)));
+            }
+            foreach ($rows as $row) {
+                if (!\is_array($row) || array_is_list($row) && [] !== $row) {
+                    throw new InvalidPage(sprintf('Eine Zeile der Tabelle „%s“ ist ungültig.', $table));
+                }
+                foreach ($row as $column => $value) {
+                    if (1 !== preg_match('/^[a-z_][a-z0-9_]{0,63}$/D', (string) $column) || !(null === $value || \is_scalar($value))) {
+                        throw new InvalidPage(sprintf('Eine Spalte der Tabelle „%s“ ist ungültig.', $table));
+                    }
+                }
+            }
+        }
+        foreach (self::CONTENT_TABLES as $table) {
+            if (!isset($tables[$table])) {
+                throw new InvalidPage(sprintf('Im Paket fehlt die Tabelle „%s“.', $table));
+            }
+        }
+        if (1 !== \count($tables['website'] ?? []) || 'default' !== ($tables['website'][0]['id'] ?? null)) {
+            throw new InvalidPage('Im Paket fehlen die Angaben zur Website.');
+        }
+
+        return $tables;
+    }
+
+    /** Jede Fassung und jeder Bereich muss ein gültiges Dokument sein - kaputte Inhalte kommen nicht herein. @throws InvalidDocument|InvalidPage */
+    private function validateDocuments(array $tables): void
+    {
+        foreach (['revision', 'partial'] as $table) {
+            foreach ($tables[$table] as $row) {
+                $document = json_decode((string) ($row['document'] ?? ''), true);
+                if (!\is_array($document)) {
+                    throw new InvalidPage(sprintf('Ein Dokument der Tabelle „%s“ ist kein JSON.', $table));
+                }
+                // Bereiche brauchen keine Hauptüberschrift, Seiten schon - wie beim Speichern.
+                $this->validator->validate($document, 'revision' === $table);
+            }
+        }
+    }
+
+    /** Ersetzt die Inhalte in einer Transaktion. */
+    private function write(array $tables, bool $withUsers): void
+    {
+        $this->db->transactional(function () use ($tables, $withUsers): void {
+            // Anfragen behalten ihr Formular: Die Kennung eines Formulars kann sich mit dem Paket
+            // ändern, die Adresse (slug) bleibt - über sie werden die Anfragen neu zugeordnet.
+            $slugs = [];
+            foreach ($this->db->fetchAllAssociative('SELECT id, slug FROM form') as $form) {
+                $slugs[$form['id']] = $form['slug'];
+            }
+            foreach (array_reverse(self::CONTENT_TABLES) as $table) {
+                $this->db->executeStatement('DELETE FROM '.$table);
+            }
+            foreach (self::CONTENT_TABLES as $table) {
+                $this->insert($table, $tables[$table]);
+            }
+            $this->mergeWebsite($tables['website'][0]);
+            if ($withUsers) {
+                $this->db->executeStatement('DELETE FROM cms_user');
+                $this->insert('cms_user', $tables['cms_user']);
+            }
+            foreach ($this->db->fetchAllAssociative('SELECT id, slug FROM form') as $form) {
+                foreach (array_keys($slugs, $form['slug'], true) as $old) {
+                    $this->db->executeStatement('UPDATE form_submission SET form_id = ? WHERE form_id = ?', [$form['id'], $old]);
+                }
+            }
+        });
+    }
+
+    /** Nur Spalten, die es hier gibt: ein Paket einer älteren Fassung kennt neuere Spalten nicht. */
+    private function insert(string $table, array $rows): void
+    {
+        $columns = array_map(static fn ($column): string => strtolower($column->getName()), $this->db->createSchemaManager()->listTableColumns($table));
+        foreach ($rows as $row) {
+            $this->db->insert($table, array_intersect_key($row, array_flip($columns)));
+        }
+    }
+
+    private function mergeWebsite(array $row): void
+    {
+        $current = $this->db->fetchAssociative('SELECT settings FROM website WHERE id = ?', ['default']);
+        $settings = json_decode((string) ($row['settings'] ?? '{}'), true) ?: [];
+        $own = json_decode((string) ($current['settings'] ?? '{}'), true) ?: [];
+        foreach (self::KEEP_SETTINGS as $key) {
+            unset($settings[$key]);
+            if (\array_key_exists($key, $own)) {
+                $settings[$key] = $own[$key];
+            }
+        }
+        $values = ['name' => (string) ($row['name'] ?? ''), 'default_locale' => (string) ($row['default_locale'] ?? 'de'), 'theme' => (string) ($row['theme'] ?? '{}'), 'settings' => json_encode($settings, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)];
+        if (false === $current) {
+            $this->db->insert('website', ['id' => 'default', ...$values]);
+        } else {
+            $this->db->update('website', $values, ['id' => 'default']);
+        }
+    }
+
+    /** Entpackt die Medien in einen eigenen Ordner neben dem Medienordner. */
+    private function extractMedia(\ZipArchive $zip): string
+    {
+        $target = $this->root.'/var/pakete/entpackt-'.bin2hex(random_bytes(6));
+        if (!@mkdir($target, 0o775, true)) {
+            throw new \RuntimeException('Ein Arbeitsordner unter var/pakete ließ sich nicht anlegen.');
+        }
+        for ($i = 0; $i < $zip->numFiles; ++$i) {
+            $name = (string) $zip->getNameIndex($i);
+            $base = substr($name, \strlen(self::MEDIA));
+            if (!str_starts_with($name, self::MEDIA) || 1 !== preg_match(self::MEDIA_NAME, $base)) {
+                continue;
+            }
+            // Gelesen und selbst geschrieben, nicht extractTo: der Zielname ist geprüft, nicht der Eintrag.
+            $stream = $zip->getStream($name);
+            $out = false === $stream ? false : fopen($target.'/'.$base, 'wb');
+            if (false === $stream || false === $out) {
+                throw new \RuntimeException(sprintf('%s ließ sich nicht entpacken.', $base));
+            }
+            stream_copy_to_stream($stream, $out, self::MAX_FILE_BYTES);
+            fclose($stream);
+            fclose($out);
+        }
+
+        return $target;
+    }
+
+    /** Leert den Medienordner (die Sicherung hat ihn) und legt die Dateien des Pakets hinein. */
+    private function replaceMedia(string $source): int
+    {
+        if (!is_dir($this->mediaDirectory) && !@mkdir($this->mediaDirectory, 0o775, true)) {
+            throw new \RuntimeException('Der Medienordner ließ sich nicht anlegen.');
+        }
+        foreach (scandir($this->mediaDirectory) ?: [] as $name) {
+            if (1 === preg_match(self::MEDIA_NAME, $name)) {
+                @unlink($this->mediaDirectory.'/'.$name);
+            }
+        }
+        $count = 0;
+        foreach (scandir($source) ?: [] as $name) {
+            if (1 === preg_match(self::MEDIA_NAME, $name) && @copy($source.'/'.$name, $this->mediaDirectory.'/'.$name)) {
+                ++$count;
+            }
+        }
+
+        return $count;
+    }
+
+    private function summary(array $tables, bool $withUsers): string
+    {
+        return sprintf(
+            '%d Seite(n), %d Fassung(en), %d Bereich(e), %d Mediendatei(en), %d Formular(e). Konten: %s. Anfragen und Statistik dieser Website bleiben.',
+            \count($tables['page']), \count($tables['revision']), \count($tables['partial']), \count($tables['media']) + \count($tables['document']), \count($tables['form']),
+            $withUsers ? 'aus dem Paket übernommen ('.\count($tables['cms_user']).')' : 'unverändert',
+        );
+    }
+
+    private function rows(string $table): array
+    {
+        return $this->db->fetchAllAssociative('SELECT * FROM '.$table);
+    }
+
+    private function fileName(string $name): string
+    {
+        $name = strtr(mb_strtolower($name), ['ä' => 'ae', 'ö' => 'oe', 'ü' => 'ue', 'ß' => 'ss']);
+        $slug = trim((string) preg_replace('/[^a-z0-9]+/', '-', $name), '-') ?: 'website';
+
+        return 'paket-'.substr($slug, 0, 40).'-'.gmdate('Ymd-His').'.zip';
+    }
+
+    private function remove(string $path): void
+    {
+        foreach (glob($path.'/*') ?: [] as $entry) {
+            is_dir($entry) ? $this->remove($entry) : @unlink($entry);
+        }
+        @rmdir($path);
+    }
+}
@@ -231,6 +231,12 @@ final class Updater
        $step($steps, 'Vorprüfung', true, 'Alle Prüfungen bestanden.');

        $target ??= $this->availableVersion();
+        // Ein Tag der Form v1.2.3 und sonst nichts: der Wert geht an git checkout (ADR 116).
+        if (null !== $target && 1 !== preg_match('/^v\d{1,4}\.\d{1,5}\.\d{1,6}$/D', $target)) {
+            $step($steps, 'Ziel bestimmen', false, 'Das Ziel hat nicht die Form v1.2.3.');
+
+            return ['ok' => false, 'steps' => $steps, 'target' => $target];
+        }
        if (null === $target) {
            $step($steps, 'Ziel bestimmen', false, 'Die Herkunft bietet keinen Tag der Form v1.2.3 an.');

@@ -293,7 +299,7 @@ final class Updater
                    throw new \RuntimeException('Die alte Git-Konfiguration konnte nicht für den Updatewechsel vorbereitet werden.');
                }
            }
-            $checkout = $this->git(['checkout', '--force', $target]);
+            $checkout = $this->git(['checkout', '--force', $target, '--']);
            $this->restoreEnvironment();
            if (!$step($steps, 'Code wechseln', $checkout['ok'], $checkout['ok'] ? 'Auf '.$target.' gewechselt.' : $checkout['output'])) {
                throw new \RuntimeException('checkout');
@@ -33,7 +33,7 @@ final class UserDirectory
    public const ROLE_HELP = [
        'ROLE_ADMIN' => 'Darf alles, einschließlich Benutzer, Design, Einstellungen, eigene Skripte und endgültiges Löschen.',
        'ROLE_PUBLISHER' => 'Darf bearbeiten und veröffentlichen, dazu Bereiche, Menüs, Formulare, Weiterleitungen und die 404-Seite – aber keine Benutzer, kein Design, keine Unternehmensdaten und keine Skripte.',
-        'ROLE_EDITOR' => 'Darf Entwürfe von Seiten und Beiträgen bearbeiten, Medien hochladen und die Statistik sehen, aber nichts veröffentlichen.',
+        'ROLE_EDITOR' => 'Darf Entwürfe von Seiten und Beiträgen bearbeiten, Medien hochladen und die Statistik sehen, aber nichts veröffentlichen – auch nicht Adresse, Papierkorb, Bereiche oder Beitragsdaten einer veröffentlichten Seite.',
    ];

    /** Bcrypt silently ignores everything after 72 bytes, so that is the honest upper limit. */
@@ -0,0 +1,9 @@
+# Dieser Ordner gehoert nicht ins Netz (ADR 116). Zeigt die Domain richtig auf public/, wird diese
+# Datei nie gelesen; zeigt sie versehentlich auf den Projektordner, sperrt sie hier alles.
+<IfModule mod_authz_core.c>
+    Require all denied
+</IfModule>
+<IfModule !mod_authz_core.c>
+    Order deny,allow
+    Deny from all
+</IfModule>
@@ -0,0 +1,27 @@
+{% extends 'admin/shell.html.twig' %}
+{% set nav = 'system' %}
+{% block title %}Import{% endblock %}
+{% block heading %}{{ result.ok ? 'Import abgeschlossen' : 'Import nicht ausgeführt' }}{% endblock %}
+{% block lead %}{{ result.ok ? 'Die Inhalte des Pakets stehen jetzt auf dieser Website.' : 'Es wurde nichts ersetzt – oder der Stand davor liegt als Sicherung bereit.' }}{% endblock %}
+{% block content %}
+<div class="card">
+    <div class="card-head"><h2>Schritte</h2></div>
+    <div class="card-body">
+        <ul class="check-list">
+            {% for step in result.steps %}
+            <li class="{{ step.ok ? 'check-ok' : 'check-bad' }}">
+                <span class="check-mark" aria-hidden="true">{{ step.ok ? '✓' : '!' }}</span>
+                <span><strong>{{ step.step }}</strong> <span class="visually-hidden">{{ step.ok ? 'erledigt' : 'fehlgeschlagen' }}:</span> {{ step.detail }}</span>
+            </li>
+            {% endfor %}
+        </ul>
+        {% if result.ok and result.users %}
+        <p class="notice" role="status">Die Konten kamen aus dem Paket. Ab der nächsten Seite gilt die Anmeldung mit den Zugangsdaten aus dem Paket.</p>
+        {% endif %}
+        {% if fontsMissing is not empty %}
+        <p class="notice" role="status">Die neue Gestaltung nutzt Schriften, die auf diesem Server noch fehlen. Unter <a href="{{ path('admin_theme') }}">Design</a> einmal „Schriften auf diesen Server holen“ drücken – bis dahin zeigt die Website die Ersatzschrift.</p>
+        {% endif %}
+        <p><a class="button-link" href="{{ path('admin_system') }}">Zurück zu System</a> · <a class="button-link" href="/" target="_blank" rel="noopener">Website ansehen</a></p>
+    </div>
+</div>
+{% endblock %}
@@ -234,6 +234,44 @@
 </div>
 {% endif %}

+<div class="card" id="paket">
+    <div class="card-head"><h2>Inhalte übertragen</h2><span class="muted">Export und Import · var/pakete</span></div>
+    <div class="card-body">
+        <p class="muted">Ein Inhaltspaket enthält Seiten mit allen Fassungen, Bereiche, Menüs, Medien und PDFs, Formulare, Weiterleitungen, Kategorien, Übersetzungen, Design und Einstellungen. Nicht darin: Anfragen, Statistik, Zugangsdaten zu Diensten (Turnstile) und – ohne Häkchen – die Konten.</p>
+
+        <h3>Exportieren</h3>
+        <form action="{{ path('admin_package_export') }}" method="post">
+            <input type="hidden" name="_csrf_token" value="{{ csrf_token('system') }}">
+            <label class="check-label"><input type="checkbox" name="benutzer" value="1"> Konten mit Passwörtern mitnehmen</label>
+            <p class="field-help">Nur nötig, wenn die andere Website noch kein Konto hat. Das Paket enthält dann die Passwort-Hashes – nicht weitergeben.</p>
+            <button class="secondary" type="submit">Paket herunterladen</button>
+        </form>
+
+        <h3>Importieren</h3>
+        <form action="{{ path('admin_package_import') }}" method="post" enctype="multipart/form-data">
+            <input type="hidden" name="_csrf_token" value="{{ csrf_token('system') }}">
+            <label for="paket-datei">Paket hochladen (.zip)</label>
+            <input id="paket-datei" type="file" name="paket" accept=".zip,application/zip">
+            <p class="field-help">Höchstens {{ uploadLimit }} je Upload (Einstellung des Hostings). Größere Pakete per FTP nach <code>var/pakete/</code> legen, dann erscheinen sie hier zur Auswahl.</p>
+            {% if packages is not empty %}
+            <fieldset class="field-group">
+                <legend>Oder ein Paket aus var/pakete/</legend>
+                {% for package in packages %}
+                <label class="check-label"><input type="radio" name="wartend" value="{{ package.name }}">
+                    <code>{{ package.name }}</code> – {% if package.manifest %}„{{ package.manifest.website }}“, Fassung {{ package.manifest.fassung }}, {{ package.manifest.inhalt.page|default(0) }} Seiten, {{ package.manifest.medien }} Dateien{% if package.manifest.benutzer %}, mit Konten{% endif %}{% else %}<span class="muted">kein gültiges Paket</span>{% endif %}
+                </label>
+                {% endfor %}
+            </fieldset>
+            {% endif %}
+            <label class="check-label"><input type="checkbox" name="benutzer" value="1"> Konten und Passwörter aus dem Paket übernehmen</label>
+            <p class="field-help">Ohne Häkchen bleiben Benutzer und Passwörter dieser Website, wie sie sind.</p>
+            <label class="check-label"><input type="checkbox" name="bestaetigt" value="1" required> Ich weiß, dass die Inhalte dieser Website ersetzt werden.</label>
+            <p class="field-help">Vorher wird automatisch eine Sicherung angelegt; während des Imports antwortet die Website mit der Wartungsseite.</p>
+            <button class="primary" type="submit">Paket importieren</button>
+        </form>
+    </div>
+</div>
+
 <div class="card">
    <div class="card-head"><h2>Sicherungen</h2><span class="muted">{{ backups|length }} vorhanden · var/backups</span></div>
    <div class="card-body">
@@ -138,7 +138,7 @@
        {% if editing|default(false) %}<p id="{{ block.id }}" class="block-unavailable{{ designClasses }}" role="note">Verknüpfte Sektion: unter Inhalt die Adresse einer Sektion eintragen.</p>{% endif %}
    {% elseif section %}
        <div id="{{ block.id }}" class="block-partialref{{ designClasses }}">
-            {% for child in section.blocks %}{% include 'blocks/block.html.twig' with {block: child, editing: editing|default(false), postLists: postLists|default({}), forms: forms|default({}), breadcrumbs: breadcrumbs|default([]), navigation: navigation|default({}), sections: sections|default({}), richText: richText|default(false), richHeadings: richHeadings|default(false), neighbours: neighbours|default({}), eagerImage: eagerImage|default(null), inHeader: inHeader|default(false)} only %}{% endfor %}
+            {# Die Sektion nach ihrem eigenen Schema-Stand: ihr Text wurde nach diesem gefiltert, nicht nach dem der Seite (ADR 116). #}{% for child in section.blocks %}{% include 'blocks/block.html.twig' with {block: child, editing: editing|default(false), postLists: postLists|default({}), forms: forms|default({}), breadcrumbs: breadcrumbs|default([]), navigation: navigation|default({}), sections: sections|default({}), richText: section.schemaVersion|default(1) >= 12, richHeadings: section.schemaVersion|default(1) >= 17, neighbours: neighbours|default({}), eagerImage: eagerImage|default(null), inHeader: inHeader|default(false)} only %}{% endfor %}
        </div>
    {% elseif editing|default(false) %}
        <p id="{{ block.id }}" class="block-unavailable{{ designClasses }}" role="note">Die verknüpfte Sektion „{{ props.partial }}“ gibt es nicht mehr. Der Verweis bleibt gespeichert.</p>
@@ -17,7 +17,9 @@
    {# Bait for automated senders. Hidden from view, from assistive technology and from tab order. #}
    <div class="form-trap" aria-hidden="true"><label for="website-{{ blockId }}">Website</label><input id="website-{{ blockId }}" name="website" type="text" tabindex="-1" autocomplete="off"></div>

-    {% if errors is not empty %}
+    {% if errors._form is defined %}
+    <p class="form-error-summary" role="alert">{{ errors._form|kant_t }}</p>
+    {% elseif errors is not empty %}
    <p class="form-error-summary" role="alert">{{ (errors|length == 1 ? 'Bitte prüfe 1 Eingabe. Die betroffenen Felder sind unten gekennzeichnet.' : 'Bitte prüfe %d Eingaben. Die betroffenen Felder sind unten gekennzeichnet.')|kant_t|format(errors|length) }}</p>
    {% endif %}

@@ -1,4 +1,6 @@
-{# Inline SVG from a fixed allowlist. No icon font, no external request, no extra stylesheet. #}
+{# Inline SVG from a fixed allowlist. No icon font, no external request, no extra stylesheet.
+   Facebook, Instagram und WhatsApp am Ende: dieselben Formen wie social-icon.html.twig, damit sie
+   auch als Symbol eines Menü-Buttons oder Bausteins wählbar sind. #}
 {% set paths = {
    'arrow-up-right': 'M6.5 17.5 17.5 6.5M8.5 6.5h9v9',
    'arrow-right': 'M4 12h15.5m-6.5-6.5 6.5 6.5-6.5 6.5',
@@ -97,6 +99,9 @@
    laptop: 'M5 5h14v10H5Zm-2.5 10h19l-1 3.5h-17Z',
    hardware: 'M4 5h16v11H4Zm4 15h8m-4-4v4',
    network: 'M5 3h14v5H5Zm0 13h14v5H5Zm7-8v8M8 8v3h8V8',
-    design: 'M4 20h16M6 16 18 4l3 3L9 19l-4 1Z'
+    design: 'M4 20h16M6 16 18 4l3 3L9 19l-4 1Z',
+    facebook: 'M15.5 4h-2.2A3.8 3.8 0 0 0 9.5 7.8V10H7v3.2h2.5V20h3.3v-6.8h2.4l.5-3.2h-2.9V8.2c0-.6.3-.9.9-.9h2Z',
+    instagram: 'M8.1 3.5h7.8a4.6 4.6 0 0 1 4.6 4.6v7.8a4.6 4.6 0 0 1-4.6 4.6H8.1a4.6 4.6 0 0 1-4.6-4.6V8.1a4.6 4.6 0 0 1 4.6-4.6ZM12 8.1a3.9 3.9 0 1 0 0 7.8 3.9 3.9 0 0 0 0-7.8ZM17 7h.01',
+    whatsapp: 'M4 20l1.4-4A8.5 8.5 0 1 1 8.6 19.1ZM9.3 9.2c0 3 2.5 5.5 5.5 5.5l1.3-1.4-2-.9-.9.8a4.1 4.1 0 0 1-2.3-2.3l.8-.9-.9-2Z'
 } %}
-<svg class="block-icon" viewBox="0 0 24 24" width="32" height="32" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" focusable="false"><path d="{{ paths[name] }}"/></svg>
+{# Strich, Farbe und Enden stehen als Regel für svg.block-icon in site.css und admin.css, nicht an jedem Symbol: eine Seite trägt um die 40 davon. #}<svg class="block-icon" viewBox="0 0 24 24" width="32" height="32" aria-hidden="true" focusable="false"><path d="{{ paths[name] }}"/></svg>
@@ -0,0 +1,15 @@
+{% extends 'install/base.html.twig' %}
+{% block heading %}Installationsschlüssel{% endblock %}
+{% block lead %}
+<p class="muted">Damit niemand anderes diese Installation zu Ende führt, öffnet sich der Installer nur mit dem Schlüssel dieser Installation. Er steht auf der Abschlussseite von <code>install.php</code>. Wer die Dateien per FTP hochgeladen hat, findet ihn in der Datei <code>{{ keyFile }}</code> – herunterladen und öffnen, er besteht aus 32 Zeichen.</p>
+{% endblock %}
+{% block content %}
+<form method="post" action="{{ path('install_key') }}">
+    <label for="schluessel">Schlüssel</label>
+    <input id="schluessel" name="schluessel" required maxlength="80" autocomplete="off" spellcheck="false" autofocus>
+    <p class="muted">Mit dem ersten Konto ist die Installation abgeschlossen; dann wird der Schlüssel gelöscht.</p>
+    <div class="sheet-actions">
+        <button class="primary" type="submit">Weiter <span aria-hidden="true">→</span></button>
+    </div>
+</form>
+{% endblock %}
@@ -70,6 +70,7 @@
    {% if needsMotion|default(false) %}<script type="module" src="/assets/motion.js?v={{ kant_version() }}"></script>{% endif %}
    {% if needsScrolled|default(false) %}<script type="module" src="/assets/scrolled.js?v={{ kant_version() }}"></script>{% endif %}
    {% if needsZoom|default(false) or needsDocument|default(false) %}<script src="/assets/lightbox.js?v={{ kant_version() }}" defer></script>{% endif %}
+    {% if needsConsent|default(false) and not editing|default(false) %}<script src="/assets/consent.js?v={{ kant_version() }}" defer></script>{% endif %}
    {% if not editing|default(false) %}{% for src in pluginScripts|default([]) %}<script src="{{ src }}" defer></script>{% endfor %}{% endif %}
    {# Own scripts of this page, as a file. Never rendered in the editor preview: the preview must
       show the layout, not run code that could change the page under the editor's hands. #}
@@ -272,7 +272,9 @@ final class ArchiveUpdateTest extends TestCase
        // Beiwerk, das eine laufende Installation nicht liest.
        // plugins/ ebenso Datei für Datei: mitgelieferte Plugins werden aktualisiert, ein vom
        // Betreiber installiertes bleibt stehen (ADR 102).
-        $anders = ['public', 'plugins', 'README.md', 'LICENSE', '.env.example'];
+        // Die .htaccess im Projektstamm ersetzt das Update nicht: sie kann dem Betreiber gehören.
+        // Fehlt sie, legt die Website sie selbst an (App\Ops\Protection, ADR 116).
+        $anders = ['public', 'plugins', 'README.md', 'LICENSE', '.env.example', '.htaccess'];
        foreach ($liste($mit[1]) as $eintrag) {
            self::assertContains(
                $eintrag,
@@ -158,7 +158,7 @@ final class BacklogTest extends TestCase

        // Abgeschickt ohne E-Mail: die Seite kommt mit Meldung zurück, am Formular im Fuß.
        $issued = time() - 10;
-        $antwort = $this->request('/formular/kontakt', 'POST', ['page' => 'home', 'block' => 'fuss-formular', 'issued' => (string) $issued, 'issuedSignature' => hash_hmac('sha256', (string) $issued, 'test-only'), 'email' => '', 'datenschutz' => 'ja']);
+        $antwort = $this->request('/formular/kontakt', 'POST', ['page' => 'home', 'block' => 'fuss-formular', 'issued' => (string) $issued, 'issuedSignature' => FormRepository::stamp('kontakt', $issued, 'test-only'), 'email' => '', 'datenschutz' => 'ja']);
        self::assertSame(422, $antwort->getStatusCode());
        self::assertStringContainsString('Dieses Feld wird benötigt.', $antwort->getContent());
    }
@@ -311,7 +311,7 @@ final class CmsTest extends TestCase
    public static function rejectedButtonIcons(): iterable
    {
        yield 'Symbol vor v25' => ['icon', 'phone', 24];
-        yield 'unbekanntes Symbol' => ['icon', 'whatsapp', 25];
+        yield 'unbekanntes Symbol' => ['icon', 'telegram', 25];
        yield 'Symbol ist kein Text' => ['icon', ['phone'], 25];
        yield 'Stellung vor v25' => ['iconPosition', 'start', 24];
        yield 'unbekannte Stellung' => ['iconPosition', 'middle', 25];
@@ -1618,7 +1618,10 @@ final class CmsTest extends TestCase
        // Und der Vordereingang verrät nicht, welche PHP-Fassung hier läuft.
        $index = (string) file_get_contents(__DIR__.'/../public/index.php');
        self::assertStringContainsString("header_remove('X-Powered-By')", $index);
-        self::assertStringContainsString('Header always unset X-Powered-By', (string) file_get_contents(__DIR__.'/../public/.htaccess'));
+        $htaccess = (string) file_get_contents(__DIR__.'/../public/.htaccess');
+        self::assertStringContainsString('Header always unset X-Powered-By', $htaccess);
+        // Ohne diese Zeile schreibt IONOS index.php endlos auf sich selbst um: weißer 500er (ADR 114).
+        self::assertStringContainsString("RewriteBase /\nRewriteRule ^index\\.php$ - [L]\nRewriteCond %{REQUEST_FILENAME} !-f", $htaccess);
    }

    public function testABackgroundPictureShrinksForSmallScreensEvenWhenSetOnce(): void
@@ -3095,6 +3098,26 @@ final class CmsTest extends TestCase
        self::assertStringNotContainsString('Viele Möglichkeiten', $this->request('/')->getContent());
    }

+    public function testALinkedSectionIsRenderedByItsOwnSchemaVersion(): void
+    {
+        // Eine Sektion mit altem Schema-Stand: ihr Text lief nicht durch den Filter für
+        // formatierten Text. In einer neueren Seite darf er deshalb nicht roh erscheinen (ADR 116).
+        $this->partials->create('section', 'alt', 'Alte Sektion', [
+            'schemaVersion' => 11, 'title' => 'Alt', 'description' => 'Alte Sektion.',
+            'blocks' => [['id' => 'alt-section', 'type' => 'section', 'children' => [
+                ['id' => 'alt-text', 'type' => 'text', 'props' => ['text' => '<meta http-equiv="refresh" content="0;url=https://fremd.example"><a href="https://fremd.example">Hier</a>']],
+            ]]],
+        ]);
+        $document = DemoContent::starter('Neu');
+        $document['schemaVersion'] = DocumentValidator::SCHEMA_VERSION;
+        $document['blocks'][] = ['id' => 'ref', 'type' => 'partialref', 'props' => ['partial' => 'alt']];
+        $this->pages->publish('page-1', $this->pages->saveDraft('page-1', $document, 0), 1);
+
+        $html = (string) $this->request('/')->getContent();
+        self::assertStringNotContainsString('<meta http-equiv="refresh"', $html);
+        self::assertStringContainsString('&lt;meta http-equiv=', $html, 'Der Text erscheint als Text.');
+    }
+
    public function testALinkedSectionChangesOnEveryPageThatEmbedsIt(): void
    {
        $sectionId = $this->partials->create('section', 'aufruf', 'Aufruf-Band', [
@@ -3467,6 +3490,24 @@ display: flex', '#b1{display:flex;color:red}'];
        $this->pages->saveDraft('page-1', $document, 0);
    }

+    public function testOwnCssStaysInsideItsBlock(): void
+    {
+        $code = new CustomCode();
+        // Geschwister des Blocks selbst liegen außerhalb - die ganze Seite wäre umgestaltbar (ADR 116).
+        foreach (['& ~ *{display:none}', '&+p{color:red}', '&[a="x]{color:red}', 'color:red /*', 'width:10px*/'] as $css) {
+            try {
+                $code->checkCss($css);
+                self::fail('Angenommen: '.$css);
+            } catch (InvalidDocument) {
+                self::addToAssertionCount(1);
+            }
+            // Was schon gespeichert ist und heute nicht mehr gilt, fällt still weg statt die Seite zu brechen.
+            self::assertSame('', $code->compileCss('b1', $css));
+        }
+        // Innerhalb des Blocks bleiben ~ und + erlaubt.
+        self::assertSame('#b1 .a~.b{color:red}#b1 h3+p{margin:0}', $code->compileCss('b1', '& .a~.b{color:red}& h3+p{margin:0}'));
+    }
+
    public function testScriptChangesAreComparedAgainstWhatIsStored(): void
    {
        $code = new CustomCode();
@@ -4543,8 +4584,10 @@ Achern']);
        self::assertStringContainsString('value="all"', $html);
        self::assertStringContainsString('value="none"', $html);
        self::assertStringContainsString('/datenschutz', $html);
-        // No script anywhere: the strict policy stays as it is.
-        self::assertStringContainsString("script-src 'none'", (string) $response->headers->get('Content-Security-Policy'));
+        // Seit ADR 115 kommt consent.js dazu, solange die Frage offen ist - als Datei von hier,
+        // nie inline. Ohne Skript bleibt das Formular mit Weiterleitung.
+        self::assertStringContainsString('<script src="/assets/consent.js?v=', $html);
+        self::assertStringContainsString("script-src 'self'", (string) $response->headers->get('Content-Security-Policy'));

        $saved = $this->request('/einwilligung', 'POST', ['choice' => 'all', 'back' => '/']);
        self::assertSame(302, $saved->getStatusCode());
@@ -4558,6 +4601,9 @@ Achern']);
        // With a decision in hand the banner is gone, but the way back to it is not.
        $decided = $this->request('/', 'GET', [], [Consent::COOKIE => (string) $cookie->getValue()]);
        self::assertStringNotContainsString('consent-bar', $decided->getContent());
+        // Nichts mehr offen: kein Skript, die Richtlinie wieder streng.
+        self::assertStringNotContainsString('consent.js', $decided->getContent());
+        self::assertStringContainsString("script-src 'none'", (string) $decided->headers->get('Content-Security-Policy'));
        self::assertStringContainsString('/einwilligung', $decided->getContent());
        self::assertSame(200, $this->request('/einwilligung', 'GET', [], [Consent::COOKIE => (string) $cookie->getValue()])->getStatusCode());
    }
@@ -4598,10 +4644,45 @@ Achern']);
            self::assertStringNotContainsString('<iframe', $html);
            self::assertStringNotContainsString('karten.example/einbetten', $html);
            self::assertStringContainsString('OpenStreetMap', $html, 'The placeholder names the provider.');
-            self::assertStringContainsString("frame-src 'none'", $policy);
+            // Die Erlaubnis steht schon in der Richtlinie (ADR 115): consent.js setzt den Rahmen
+            // nach der Einwilligung ohne Neuladen ein, und eine Richtlinie ändert sich danach nicht
+            // mehr. Geladen wird dadurch nichts - es gibt keinen Rahmen und keine Adresse.
+            self::assertStringContainsString('frame-src https://karten.example', $policy);
+            self::assertStringContainsString('<script src="/assets/consent.js?v=', $html);
        }
    }

+    public function testTheConsentFormRedirectsOnlyWithinThisSite(): void
+    {
+        $this->askConsent();
+        // Browser entfernen Tabulator und Zeilenumbruch: aus /<Tab>/fremd würde //fremd (ADR 116).
+        foreach (["/\t/fremd.example", "/\n/fremd.example", '//fremd.example', '/\fremd.example', 'https://fremd.example', '/ /fremd.example'] as $back) {
+            self::assertSame('/', $this->request('/einwilligung', 'POST', ['choice' => 'none', 'back' => $back])->headers->get('Location'), json_encode($back));
+        }
+        self::assertSame('/kontakt?a=1#x', $this->request('/einwilligung', 'POST', ['choice' => 'none', 'back' => '/kontakt?a=1#x'])->headers->get('Location'));
+    }
+
+    public function testTheConsentScriptSavesWithoutARedirect(): void
+    {
+        $this->askConsent();
+
+        // consent.js kennzeichnet seine Anfrage; dann gibt es das Cookie ohne Weiterleitung.
+        $saved = $this->request('/einwilligung', 'POST', ['choice' => 'all', 'back' => '/'], [], ['HTTP_X_KANT_CONSENT' => '1']);
+        self::assertSame(204, $saved->getStatusCode());
+        self::assertNull($saved->headers->get('Location'));
+        self::assertSame('', $saved->getContent());
+        $cookie = $saved->headers->getCookies()[0];
+        self::assertSame(Consent::COOKIE, $cookie->getName());
+        self::assertStringContainsString('external', (string) $cookie->getValue());
+
+        // Von einer fremden Website bleibt es bei der Antwort ohne Cookie, wie beim Formular.
+        $fremd = $this->request('/einwilligung', 'POST', ['choice' => 'all'], [], ['HTTP_X_KANT_CONSENT' => '1', 'HTTP_SEC_FETCH_SITE' => 'cross-site']);
+        self::assertSame([], $fremd->headers->getCookies());
+
+        // Ohne die Kopfzeile bleibt alles beim Alten: Weiterleitung zurück.
+        self::assertSame(302, $this->request('/einwilligung', 'POST', ['choice' => 'none', 'back' => '/'])->getStatusCode());
+    }
+
    public function testTheEmbedButtonGrantsOnlyItsOwnGroupAndKeepsWhatWasGrantedBefore(): void
    {
        $document = DemoContent::starter('Mit Karte');
@@ -4710,7 +4791,7 @@ Achern']);
        }
    }

-    private function request(string $url, string $method = 'GET', array $body = [], array $cookies = []): Response
+    private function request(string $url, string $method = 'GET', array $body = [], array $cookies = [], array $server = []): Response
    {
        $previous = [];
        foreach (['APP_SECRET' => 'test-only', 'DATABASE_URL' => 'sqlite:///'.str_replace('\\', '/', $this->path), 'SITE_ORIGIN' => 'https://cms.test', 'MEDIA_DIRECTORY' => $this->path.'-media', 'FONT_DIRECTORY' => $this->path.'-fonts', 'ASSET_DIRECTORY' => $this->path.'-assets'] as $key => $value) {
@@ -4719,7 +4800,7 @@ Achern']);
        }
        $kernel = new Kernel('test', false);
        try {
-            $request = Request::create($url, $method, $body, $cookies);
+            $request = Request::create($url, $method, $body, $cookies, [], $server);
            $response = $kernel->handle($request);
            // Counting happens on kernel.terminate, so a test that does not terminate would
            // silently test a different application than the one that runs.
@@ -356,6 +356,54 @@ final class EditorSecurityTest extends WebTestCase
        self::assertSame(1, (int) $this->db->fetchOne('SELECT COUNT(*) FROM page'));
    }

+    public function testEditorsChangeLivePagesOnlyThroughAPublisher(): void
+    {
+        // Eine veröffentlichte Unterseite und ein reiner Entwurf (ADR 116).
+        $pages = new PageRepository($this->db, new DocumentValidator(), new SiteSettings($this->db, new MediaLibrary($this->db, $this->path.'-media')));
+        $live = $pages->createPage('leistungen', null, 'page', DemoContent::starter('Leistungen'));
+        $seite = $pages->findForEditor($live);
+        $pages->publish($live, $seite['draft_revision_id'], $seite['version']);
+        $entwurf = $pages->createPage('entwurf', null, 'page', DemoContent::starter('Entwurf'));
+        $version = static fn (string $id): int => (int) $pages->findForEditor($id)['version'];
+
+        $client = $this->login('editor');
+        $token = $client->request('GET', '/admin')->filter('input[name="_csrf_token"]')->last()->attr('value');
+        foreach (['move' => ['slug' => 'umbenannt'], 'trash' => [], 'bereiche' => ['headerArea' => '', 'footerArea' => 'none'], 'meta' => ['robots' => 'noindex']] as $aktion => $felder) {
+            $client->request('POST', '/admin/pages/'.$live.'/'.$aktion, ['_csrf_token' => $token, 'expectedVersion' => $version($live), ...$felder]);
+            self::assertResponseRedirects();
+        }
+        $nachher = $this->db->fetchAssociative('SELECT path, deleted_at, footer_area, robots FROM page WHERE id = ?', [$live]);
+        self::assertSame('leistungen', $nachher['path'], 'Ein Redakteur verschiebt keine veröffentlichte Seite.');
+        self::assertNull($nachher['deleted_at'], 'Ein Redakteur legt keine veröffentlichte Seite in den Papierkorb.');
+        self::assertNull($nachher['footer_area']);
+        self::assertNotSame('noindex', $nachher['robots']);
+
+        // Einen Entwurf, der nie online war, bearbeitet er weiter frei.
+        $client->request('POST', '/admin/pages/'.$entwurf.'/move', ['_csrf_token' => $token, 'expectedVersion' => $version($entwurf), 'slug' => 'neuer-name']);
+        self::assertSame('neuer-name', $this->db->fetchOne('SELECT path FROM page WHERE id = ?', [$entwurf]));
+
+        // Wer veröffentlichen darf, darf auch das.
+        $client = $this->login('publisher', $client);
+        $token = $client->request('GET', '/admin')->filter('input[name="_csrf_token"]')->last()->attr('value');
+        $client->request('POST', '/admin/pages/'.$live.'/move', ['_csrf_token' => $token, 'expectedVersion' => $version($live), 'slug' => 'umbenannt']);
+        self::assertSame('umbenannt', $this->db->fetchOne('SELECT path FROM page WHERE id = ?', [$live]));
+    }
+
+    public function testAScheduledPublicationPublishesTheRevisionThatWasScheduled(): void
+    {
+        $pages = new PageRepository($this->db, new DocumentValidator(), new SiteSettings($this->db, new MediaLibrary($this->db, $this->path.'-media')));
+        $id = $pages->createPage('termin', null, 'page', DemoContent::starter('Geprüfter Stand'));
+        $geprueft = $pages->findForEditor($id)['draft_revision_id'];
+        $pages->schedule($id, '2026-01-01 08:00', (int) $pages->findForEditor($id)['version']);
+        // Nach dem Planen speichert jemand einen anderen Entwurf.
+        $pages->saveDraft($id, DemoContent::starter('Später gespeichert'), (int) $pages->findForEditor($id)['version']);
+        self::assertNotSame($geprueft, $pages->findForEditor($id)['draft_revision_id']);
+
+        self::assertSame(['termin'], $pages->publishDue());
+        self::assertSame($geprueft, $this->db->fetchOne('SELECT published_revision_id FROM page WHERE id = ?', [$id]), 'Online geht der geplante Stand, nicht der spätere Entwurf.');
+        self::assertNull($this->db->fetchOne('SELECT publish_revision_id FROM page WHERE id = ?', [$id]));
+    }
+
    public function testAdministratorsDeleteAPageWithAllRevisionsOnlyWithACsrfToken(): void
    {
        $client = $this->login('admin');
@@ -499,7 +547,7 @@ final class EditorSecurityTest extends WebTestCase
    {
        return [
            'page' => 'home', 'block' => 'formblock', 'website' => '',
-            'issued' => $issued, 'issuedSignature' => hash_hmac('sha256', $issued, 'isolated-test-secret'),
+            'issued' => $issued, 'issuedSignature' => FormRepository::stamp('kontakt', (int) $issued, 'isolated-test-secret'),
            'name' => 'Umut', 'email' => 'umut@example.com', 'thema' => 'Beratung',
            'nachricht' => 'Bitte um Rückruf.', 'datenschutz' => 'ja',
        ];
@@ -611,7 +659,7 @@ final class EditorSecurityTest extends WebTestCase
     */
    public static function droppedSubmissions(): iterable
    {
-        $sign = static fn (string $issued): string => hash_hmac('sha256', $issued, 'isolated-test-secret');
+        $sign = static fn (string $issued): string => FormRepository::stamp('kontakt', (int) $issued, 'isolated-test-secret');
        yield 'honeypot filled' => [static fn (array $body): array => [...$body, 'website' => 'https://spam.example']];
        yield 'submitted too fast' => [static fn (array $body): array => [...$body, 'issued' => (string) time(), 'issuedSignature' => $sign((string) time())]];
        yield 'timestamp forged' => [static fn (array $body): array => [...$body, 'issuedSignature' => 'nicht-signiert']];
@@ -650,7 +698,47 @@ final class EditorSecurityTest extends WebTestCase
        $client->request('POST', '/formular/kontakt', $this->validBody((string) (time() - 10)));
        self::assertResponseStatusCodeSame(303);
        self::assertSame(FormRepository::RATE_LIMIT, (int) $this->db->fetchOne('SELECT COUNT(*) FROM form_submission'));
-        self::assertTrue($forms->rateLimited(hash_hmac('sha256', '127.0.0.1', 'isolated-test-secret')));
+        self::assertTrue($forms->rateLimited(FormRepository::senderKey('127.0.0.1', 'isolated-test-secret')));
+    }
+
+    public function testSendersOfOneIpv6NetworkCountTogether(): void
+    {
+        // Ein Anschluss hat ein ganzes /64-Netz; jede Adresse daraus ist derselbe Absender (ADR 116).
+        $a = FormRepository::senderKey('2001:db8:1:2:aaaa::1', 's');
+        self::assertSame($a, FormRepository::senderKey('2001:db8:1:2:ffff:1:2:3', 's'));
+        self::assertNotSame($a, FormRepository::senderKey('2001:db8:1:3::1', 's'));
+        self::assertNotSame(FormRepository::senderKey('192.0.2.1', 's'), FormRepository::senderKey('192.0.2.2', 's'));
+    }
+
+    public function testAStampFromOneFormDoesNotOpenAnother(): void
+    {
+        // Das Siegel gilt für ein Formular; eines von einer anderen Seite lässt sich nicht
+        // wiederverwenden (ADR 116). Der Versand wird still verworfen wie bei jedem Bot.
+        $this->contactForm();
+        $this->pageWithForm();
+        $client = self::createClient();
+        $issued = (string) (time() - 10);
+        $client->request('POST', '/formular/kontakt', [...$this->validBody($issued), 'issuedSignature' => FormRepository::stamp('anderes', (int) $issued, 'isolated-test-secret')]);
+        self::assertResponseStatusCodeSame(303);
+        self::assertSame(0, (int) $this->db->fetchOne('SELECT COUNT(*) FROM form_submission'));
+    }
+
+    public function testAFloodStopsStoringAndTellsTheVisitor(): void
+    {
+        $forms = $this->contactForm();
+        $this->pageWithForm();
+        $form = $forms->findBySlug('kontakt');
+        // Viele verschiedene Absender in der letzten Stunde: die Grenze je Formular greift.
+        for ($i = 0; $i < FormRepository::FORM_RATE_LIMIT; ++$i) {
+            $forms->store($form['id'], ['name' => 'x'], true, 'absender-'.$i);
+        }
+        self::assertTrue($forms->flooded($form['id']));
+        $client = self::createClient();
+        $client->request('POST', '/formular/kontakt', $this->validBody((string) (time() - 10)));
+        // Sichtbar statt still: ein echter Besucher erfährt, dass er anrufen sollte.
+        self::assertResponseStatusCodeSame(422);
+        self::assertStringContainsString('Gerade gehen sehr viele Anfragen ein', (string) $client->getResponse()->getContent());
+        self::assertSame(FormRepository::FORM_RATE_LIMIT, (int) $this->db->fetchOne('SELECT COUNT(*) FROM form_submission'));
    }

    public function testAFormCarriesItsOwnColoursOntoThePageAndTheAdministrationRefusesBadOnes(): void
@@ -291,7 +291,7 @@ final class FormStepsTest extends TestCase

        $issued = time() - 10;
        $grund = [
-            'page' => 'home', 'block' => 'preis', 'issued' => (string) $issued, 'issuedSignature' => hash_hmac('sha256', (string) $issued, 'test-only'),
+            'page' => 'home', 'block' => 'preis', 'issued' => (string) $issued, 'issuedSignature' => FormRepository::stamp('preisfinder', $issued, 'test-only'),
            'immobilienart' => 'Grundstück', 'wohnflaeche' => '99', 'ausstattung' => ['Balkon'], 'flaeche' => '640', 'email' => 'x@example.org', 'datenschutz' => 'ja',
        ];
        $antwort = $this->request('/formular/preisfinder', 'POST', $grund);
@@ -23,6 +23,8 @@ final class InstallFlowTest extends TestCase
 {
    private string $root;
    private string $database;
+    /** @var array<string, string> Cookies wie im Browser: der Nachweis des Installationsschlüssels. */
+    private array $cookies = [];

    protected function setUp(): void
    {
@@ -58,6 +60,11 @@ final class InstallFlowTest extends TestCase
        self::assertSame(302, $response->getStatusCode());
        self::assertSame('/install', $response->headers->get('Location'));

+        // 0b. Ohne Installationsschlüssel öffnet sich kein Schritt (ADR 116).
+        self::assertSame('/install/schluessel', $this->request('/install')->headers->get('Location'));
+        self::assertSame('/install/schluessel', $this->request('/install/datenbank')->headers->get('Location'));
+        $this->unlock();
+
        // 1. The system check.
        $check = $this->request('/install');
        self::assertSame(200, $check->getStatusCode());
@@ -92,6 +99,9 @@ final class InstallFlowTest extends TestCase
        self::assertStringContainsString('Fertig.', $done->getContent());
        self::assertStringContainsString('Impressum und Datenschutzerklärung ausfüllen', $done->getContent());

+        // Der Schlüssel hat seine Arbeit getan und liegt nicht mehr herum.
+        self::assertFileDoesNotExist($this->root.'/var/install.key');
+
        // 6. The installer is over, and the website answers.
        self::assertSame(404, $this->request('/install')->getStatusCode());
        self::assertSame(404, $this->request('/install/konto')->getStatusCode());
@@ -105,8 +115,41 @@ final class InstallFlowTest extends TestCase
        self::assertSame(200, $this->request('/admin/login')->getStatusCode());
    }

+    public function testTheInstallerOpensOnlyWithItsKey(): void
+    {
+        // Wer die frische Installation zuerst aufruft, bekommt nur die Frage nach dem Schlüssel.
+        $page = $this->request('/install/schluessel');
+        self::assertSame(200, $page->getStatusCode());
+        self::assertStringContainsString('Installationsschlüssel', (string) $page->getContent());
+        $key = trim((string) file_get_contents($this->root.'/var/install.key'));
+        self::assertMatchesRegularExpression('/^[a-f0-9]{32}$/', $key);
+
+        // Ein falscher Schlüssel öffnet nichts und setzt kein Cookie.
+        $wrong = $this->request('/install/schluessel', 'POST', ['schluessel' => str_repeat('0', 32)]);
+        self::assertSame(200, $wrong->getStatusCode());
+        self::assertStringContainsString('passt nicht', (string) $wrong->getContent());
+        self::assertSame([], $wrong->headers->getCookies());
+        // Auch ein selbst gebautes Cookie nicht.
+        $this->cookies = ['kant_install' => hash_hmac('sha256', 'installer', 'geraten')];
+        self::assertSame('/install/schluessel', $this->request('/install')->headers->get('Location'));
+
+        // Der Verweis von install.php trägt den Schlüssel in der Adresse; danach geht es ohne ihn weiter.
+        $this->cookies = [];
+        $open = $this->request('/install/schluessel?schluessel='.$key);
+        self::assertSame('/install', $open->headers->get('Location'));
+        $cookie = $open->headers->getCookies()[0];
+        self::assertSame('kant_install', $cookie->getName());
+        self::assertTrue($cookie->isHttpOnly());
+        self::assertSame('strict', $cookie->getSameSite());
+        self::assertSame('/install', $cookie->getPath());
+        self::assertNotSame($key, $cookie->getValue(), 'Im Cookie steht ein Nachweis, nicht der Schlüssel.');
+        $this->cookies = ['kant_install' => (string) $cookie->getValue()];
+        self::assertSame(200, $this->request('/install')->getStatusCode());
+    }
+
    public function testAStepWithoutItsRequirementSendsYouBack(): void
    {
+        $this->unlock();
        // Somebody who guesses the address of a later step does not get past the missing database.
        self::assertSame('/install/datenbank', $this->request('/install/migration')->headers->get('Location'));
        self::assertSame('/install/migration', $this->request('/install/website')->headers->get('Location'));
@@ -118,6 +161,15 @@ final class InstallFlowTest extends TestCase
        self::assertFileDoesNotExist($this->root.'/.env');
    }

+    /** Gibt den Installationsschlüssel ein, wie es der Betreiber tut, und behält das Cookie. */
+    private function unlock(): void
+    {
+        $this->request('/install/schluessel');
+        $response = $this->request('/install/schluessel', 'POST', ['schluessel' => trim((string) file_get_contents($this->root.'/var/install.key'))]);
+        self::assertSame('/install', $response->headers->get('Location'));
+        $this->cookies['kant_install'] = (string) $response->headers->getCookies()[0]->getValue();
+    }
+
    /** Posts a form with the signature the rendered page carries, the way a browser would. */
    private function submit(string $url, Response $page, array $fields): Response
    {
@@ -143,7 +195,7 @@ final class InstallFlowTest extends TestCase
        }
        $kernel = new InstallTestKernel($this->root);
        try {
-            $request = Request::create($url, $method, $body);
+            $request = Request::create($url, $method, $body, $this->cookies);
            $response = $kernel->handle($request);
            $kernel->terminate($request, $response);

@@ -12,6 +12,7 @@ use App\Domain\CmsUser;
 use App\Domain\InvalidPage;
 use App\Infrastructure\ConnectionFactory;
 use App\Ops\Installation;
+use App\Ops\Protection;
 use Doctrine\DBAL\Connection;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
@@ -48,6 +49,38 @@ final class InstallationTest extends TestCase
        $this->installation = $this->make();
    }

+    public function testMissingLockFilesAreAddedButAnOwnRootFileStays(): void
+    {
+        // var/ gibt es nicht im Archiv, also legt die Website die Sperrdatei selbst an (ADR 116).
+        mkdir($this->root.'/config/schutz', 0o775, true);
+        mkdir($this->root.'/vendor', 0o775, true);
+        foreach (['sperren', 'stamm'] as $name) {
+            copy(\dirname(__DIR__).'/config/schutz/'.$name.'.htaccess', $this->root.'/config/schutz/'.$name.'.htaccess');
+        }
+        file_put_contents($this->root.'/.htaccess', '# eigene Regeln
+');
+        Protection::reset();
+        Protection::ensure($this->root);
+        self::assertStringContainsString('Require all denied', (string) file_get_contents($this->root.'/var/.htaccess'));
+        self::assertStringContainsString('Require all denied', (string) file_get_contents($this->root.'/vendor/.htaccess'));
+        self::assertSame('# eigene Regeln
+', file_get_contents($this->root.'/.htaccess'), 'Eine eigene Datei im Projektstamm bleibt.');
+        Protection::reset();
+    }
+
+    public function testTheInstallKeyIsCreatedOnceAndCheckedStrictly(): void
+    {
+        $key = $this->installation->installKey();
+        self::assertMatchesRegularExpression('/^[a-f0-9]{32}$/', $key);
+        self::assertSame($key, $this->installation->installKey(), 'Einmal angelegt, bleibt er.');
+        self::assertTrue($this->installation->acceptsKey(' '.strtoupper($key).' '), 'Abgetippt mit Leerzeichen und Großbuchstaben zählt.');
+        self::assertFalse($this->installation->acceptsKey(substr($key, 0, 31)));
+        self::assertFalse($this->installation->acceptsKey(''));
+        self::assertTrue($this->installation->acceptsProof($this->installation->keyProof()));
+        self::assertFalse($this->installation->acceptsProof(''));
+        self::assertFalse($this->installation->acceptsProof($key));
+    }
+
    protected function tearDown(): void
    {
        $this->db->close();
@@ -85,6 +85,25 @@ final class SingleFileInstallerTest extends TestCase
        self::assertFileDoesNotExist(\dirname($this->target).'/entwischt.txt');
    }

+    public function testTheInstallerKeyIsWrittenForTheWebInstaller(): void
+    {
+        // install.php legt den Schlüssel dort an, wo der Installer ihn sucht (ADR 116).
+        $key = kant_install_key($this->target);
+        self::assertMatchesRegularExpression('/^[a-f0-9]{32}$/', $key);
+        self::assertSame($key, trim((string) file_get_contents($this->target.'/var/install.key')));
+        self::assertSame($key, kant_install_key($this->target), 'Ein zweiter Aufruf liest denselben Schlüssel.');
+    }
+
+    public function testTheReleaseCarriesItsLockFiles(): void
+    {
+        // Die Sperrdateien liegen im Repository und gleichen ihrer Vorlage (ADR 116).
+        $root = \dirname(__DIR__);
+        self::assertFileEquals($root.'/config/schutz/stamm.htaccess', $root.'/.htaccess');
+        foreach (['bin', 'config', 'migrations', 'plugins', 'src', 'templates'] as $ordner) {
+            self::assertFileEquals($root.'/config/schutz/sperren.htaccess', $root.'/'.$ordner.'/.htaccess', $ordner);
+        }
+    }
+
    public function testThePreflightNamesWhatIsMissing(): void
    {
        $checks = kant_checks($this->target);
@@ -0,0 +1,177 @@
+<?php
+
+namespace App\Tests;
+
+use App\Content\DemoContent;
+use App\Content\DocumentValidator;
+use App\Content\FormRepository;
+use App\Content\MediaLibrary;
+use App\Content\PageRepository;
+use App\Content\SiteSettings;
+use App\Infrastructure\ConnectionFactory;
+use App\Ops\Backup;
+use App\Ops\CommandRunner;
+use App\Ops\SitePackage;
+use App\Ops\Updater;
+use Doctrine\DBAL\Connection;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Inhaltspakete zwischen zwei Installationen (ADR 118).
+ *
+ * Der Anlass war das Passwort, das sich nach jedem Hochladen einer Datenbank änderte. Deshalb steht
+ * der Test vorn, der das festhält: Inhalte kommen, Konten, Anfragen und Zugangsdaten zu Diensten
+ * bleiben - außer man nimmt die Konten ausdrücklich mit.
+ */
+final class SitePackageTest extends TestCase
+{
+    /** @var array<string, array{root: string, db: Connection, package: SitePackage}> */
+    private array $sites = [];
+
+    protected function setUp(): void
+    {
+        foreach (['quelle', 'ziel'] as $name) {
+            $root = str_replace('\\', '/', sys_get_temp_dir()).'/kant-paket-'.$name.'-'.bin2hex(random_bytes(5));
+            mkdir($root.'/var/media', 0o775, true);
+            file_put_contents($root.'/VERSION', "1.32.0\n");
+            $url = 'sqlite:///'.$root.'/var/cms.db';
+            $db = ConnectionFactory::create($url);
+            TestSchema::build($db);
+            $db->insert('website', ['id' => 'default', 'name' => 'Website '.$name, 'default_locale' => 'de', 'theme' => '{}', 'settings' => json_encode(['turnstileSecret' => 'geheim-'.$name, 'turnstileSiteKey' => 'schluessel-'.$name])]);
+            $pages = new PageRepository($db, new DocumentValidator(), new SiteSettings($db, new MediaLibrary($db, $root.'/var/media')));
+            $pages->createPage('ziel' === $name ? 'alte-seite' : 'neue-seite', null, 'page', DemoContent::starter('Seite der '.$name));
+            (new FormRepository($db))->save('anfrage', 'Anfrage', [['name' => 'email', 'type' => 'email', 'label' => 'E-Mail', 'required' => true]], ['recipient' => 'info@example.org'], 0);
+            $db->insert('cms_user', ['id' => 'u-'.$name, 'username' => $name, 'password_hash' => 'hash-'.$name, 'roles' => '["ROLE_ADMIN"]']);
+            file_put_contents($root.'/var/media/'.str_repeat('ziel' === $name ? 'b' : 'a', 32).'-480.webp', 'bild '.$name);
+            $runner = new CommandRunner();
+            $this->sites[$name] = ['root' => $root, 'db' => $db, 'package' => new SitePackage($db, new DocumentValidator(), new Backup($root, $url, $root.'/var/media', $db, $runner), new Updater($root, $url, $runner, $db), $root, $root.'/var/media')];
+        }
+        // Eine Anfrage, die es nur auf der Zielwebsite gibt - sie muss den Import überstehen.
+        $ziel = $this->sites['ziel']['db'];
+        $ziel->insert('form_submission', ['id' => 's1', 'form_id' => $ziel->fetchOne('SELECT id FROM form'), 'data' => '{}', 'sender_hash' => 'x', 'created_at' => '2026-10-12 10:00:00', 'delivered' => 0]);
+    }
+
+    protected function tearDown(): void
+    {
+        foreach ($this->sites as $site) {
+            $site['db']->close();
+        }
+        gc_collect_cycles();
+        foreach ($this->sites as $site) {
+            self::remove($site['root']);
+        }
+    }
+
+    public function testImportReplacesContentAndKeepsAccountsSubmissionsAndServiceKeys(): void
+    {
+        $file = $this->sites['quelle']['package']->export();
+        $result = $this->sites['ziel']['package']->import($file);
+        self::assertTrue($result['ok'], json_encode($result['steps'], JSON_UNESCAPED_UNICODE));
+
+        $db = $this->sites['ziel']['db'];
+        self::assertSame(['neue-seite'], $db->fetchFirstColumn('SELECT path FROM page'));
+        self::assertSame('Website quelle', $db->fetchOne('SELECT name FROM website'));
+        // Das Konto der Zielwebsite bleibt - genau der Anlass dieses Imports.
+        self::assertSame([['username' => 'ziel', 'password_hash' => 'hash-ziel']], $db->fetchAllAssociative('SELECT username, password_hash FROM cms_user'));
+        // Die Anfrage hängt jetzt am Formular aus dem Paket (gleiche Adresse, neue Kennung).
+        self::assertSame($db->fetchOne('SELECT id FROM form'), $db->fetchOne('SELECT form_id FROM form_submission WHERE id = ?', ['s1']));
+        self::assertSame($this->sites['quelle']['db']->fetchOne('SELECT id FROM form'), $db->fetchOne('SELECT id FROM form'));
+        // Zugangsdaten zu Diensten bleiben, wo sie waren - und standen auch nicht im Paket.
+        $settings = json_decode((string) $db->fetchOne('SELECT settings FROM website'), true);
+        self::assertSame(['geheim-ziel', 'schluessel-ziel'], [$settings['turnstileSecret'], $settings['turnstileSiteKey']]);
+        $zip = new \ZipArchive();
+        $zip->open($file);
+        self::assertStringNotContainsString('geheim-quelle', (string) $zip->getFromName(SitePackage::DATA));
+        self::assertStringNotContainsString('hash-quelle', (string) $zip->getFromName(SitePackage::DATA), 'Ohne Häkchen keine Konten im Paket.');
+        $zip->close();
+        // Der Medienordner ist der des Pakets; der vorige Stand liegt in der Sicherung.
+        self::assertSame([str_repeat('a', 32).'-480.webp'], array_values(array_diff(scandir($this->sites['ziel']['root'].'/var/media'), ['.', '..'])));
+        self::assertNotEmpty(glob($this->sites['ziel']['root'].'/var/backups/sicherung-*'), 'Vor dem Import wird gesichert.');
+        self::assertFileDoesNotExist($this->sites['ziel']['root'].'/var/maintenance');
+    }
+
+    public function testAccountsComeAlongOnlyWhenChosenOnBothSides(): void
+    {
+        // Paket ohne Konten, Häkchen gesetzt: abgelehnt, nichts geändert.
+        $ohne = $this->sites['quelle']['package']->export();
+        $result = $this->sites['ziel']['package']->import($ohne, true);
+        self::assertFalse($result['ok']);
+        self::assertSame(['alte-seite'], $this->sites['ziel']['db']->fetchFirstColumn('SELECT path FROM page'));
+
+        // Paket mit Konten, aber ohne Häkchen beim Import: die Konten bleiben.
+        $mit = $this->sites['quelle']['package']->export(true);
+        self::assertTrue($this->sites['ziel']['package']->import($mit)['ok']);
+        self::assertSame(['ziel'], $this->sites['ziel']['db']->fetchFirstColumn('SELECT username FROM cms_user'));
+
+        // Mit Häkchen: die Konten des Pakets.
+        self::assertTrue($this->sites['ziel']['package']->import($mit, true)['ok']);
+        self::assertSame([['username' => 'quelle', 'password_hash' => 'hash-quelle']], $this->sites['ziel']['db']->fetchAllAssociative('SELECT username, password_hash FROM cms_user'));
+    }
+
+    public function testAPackageFromANewerVersionIsRefused(): void
+    {
+        file_put_contents($this->sites['quelle']['root'].'/VERSION', "9.0.0\n");
+        $result = $this->sites['ziel']['package']->import($this->sites['quelle']['package']->export());
+        self::assertFalse($result['ok']);
+        self::assertStringContainsString('Erst diese Website aktualisieren', $result['steps'][0]['detail']);
+        self::assertSame(['alte-seite'], $this->sites['ziel']['db']->fetchFirstColumn('SELECT path FROM page'));
+    }
+
+    /** @return iterable<string, array{callable(\ZipArchive): void, string}> */
+    public static function tamperedPackages(): iterable
+    {
+        yield 'fremde Datei' => [static fn (\ZipArchive $zip) => $zip->addFromString('../../public/hallo.php', '<?php'), 'gehört nicht in ein Inhaltspaket'];
+        yield 'Skript als Medium' => [static fn (\ZipArchive $zip) => $zip->addFromString('medien/shell.php', '<?php'), 'gehört nicht in ein Inhaltspaket'];
+        yield 'veränderter Inhalt' => [static function (\ZipArchive $zip): void {
+            $zip->addFromString(SitePackage::DATA, str_replace('Seite der quelle', 'Untergeschoben', (string) $zip->getFromName(SitePackage::DATA)));
+        }, 'Prüfsumme'];
+        yield 'fremde Tabelle' => [static function (\ZipArchive $zip): void {
+            $data = json_decode((string) $zip->getFromName(SitePackage::DATA), true);
+            $data['tabellen']['form_submission'] = [];
+            $raw = json_encode($data);
+            $manifest = json_decode((string) $zip->getFromName(SitePackage::MANIFEST), true);
+            $manifest['sha256'] = hash('sha256', $raw);
+            $zip->addFromString(SitePackage::DATA, $raw);
+            $zip->addFromString(SitePackage::MANIFEST, json_encode($manifest));
+        }, 'gehört nicht in ein Inhaltspaket'];
+        yield 'ungültiges Dokument' => [static function (\ZipArchive $zip): void {
+            $data = json_decode((string) $zip->getFromName(SitePackage::DATA), true);
+            $data['tabellen']['revision'][0]['document'] = json_encode(['schemaVersion' => 1, 'title' => 'x', 'blocks' => [['id' => 'a', 'type' => 'unbekannt']]]);
+            $raw = json_encode($data);
+            $manifest = json_decode((string) $zip->getFromName(SitePackage::MANIFEST), true);
+            $manifest['sha256'] = hash('sha256', $raw);
+            $zip->addFromString(SitePackage::DATA, $raw);
+            $zip->addFromString(SitePackage::MANIFEST, json_encode($manifest));
+        }, ''];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('tamperedPackages')]
+    public function testATamperedPackageChangesNothing(callable $tamper, string $message): void
+    {
+        $file = $this->sites['quelle']['package']->export();
+        $zip = new \ZipArchive();
+        $zip->open($file);
+        $tamper($zip);
+        $zip->close();
+
+        $result = $this->sites['ziel']['package']->import($file);
+        self::assertFalse($result['ok']);
+        self::assertStringContainsString($message, json_encode($result['steps'], JSON_UNESCAPED_UNICODE));
+        self::assertSame(['alte-seite'], $this->sites['ziel']['db']->fetchFirstColumn('SELECT path FROM page'));
+        self::assertSame([str_repeat('b', 32).'-480.webp'], array_values(array_diff(scandir($this->sites['ziel']['root'].'/var/media'), ['.', '..'])));
+        self::assertFileDoesNotExist($this->sites['ziel']['root'].'/public/hallo.php');
+    }
+
+    private static function remove(string $path): void
+    {
+        if (!is_dir($path)) {
+            return;
+        }
+        foreach (scandir($path) ?: [] as $entry) {
+            if ('.' !== $entry && '..' !== $entry) {
+                is_dir($path.'/'.$entry) ? self::remove($path.'/'.$entry) : @unlink($path.'/'.$entry);
+            }
+        }
+        @rmdir($path);
+    }
+}
@@ -23,6 +23,7 @@ use DoctrineMigrations\Version20260915000100;
 use DoctrineMigrations\Version20260916000100;
 use DoctrineMigrations\Version20260917000100;
 use DoctrineMigrations\Version20261009000100;
+use DoctrineMigrations\Version20261012000100;
 use Psr\Log\NullLogger;

 /**
@@ -57,6 +58,7 @@ final class TestSchema
            Version20260916000100::class,
            Version20260917000100::class,
            Version20261009000100::class,
+            Version20261012000100::class,
        ] as $migration) {
            (new $migration($db, new NullLogger()))->up($schema);
        }
@@ -4,6 +4,7 @@ namespace App\Tests;

 use App\Content\DemoContent;
 use App\Content\DocumentValidator;
+use App\Content\FormRepository;
 use App\Content\Languages;
 use App\Content\MediaLibrary;
 use App\Content\PageRepository;
@@ -312,7 +313,7 @@ final class TranslationTest extends TestCase
    public function testFormsSpeakTheLanguageOfThePageButSendInTheMainLanguage(): void
    {
        $this->languages->save(['en']);
-        $forms = new \App\Content\FormRepository($this->db);
+        $forms = new FormRepository($this->db);
        $translations = ['en' => ['buttonLabel' => 'Send request', 'success' => 'Thanks!', 'fields' => [
            'art' => ['label' => 'Type of enquiry', 'options' => ['Beratung' => 'Advice', 'Angebot' => 'Quote', 'Gibt es nicht' => 'x']],
            'email' => ['label' => 'Email', 'help' => ''],
@@ -352,7 +353,7 @@ final class TranslationTest extends TestCase
        self::assertStringNotContainsString('name="language"', $german);

        $issued = time() - 10;
-        $body = ['page' => 'kontakt', 'block' => 'f1', 'language' => 'en', 'issued' => (string) $issued, 'issuedSignature' => hash_hmac('sha256', (string) $issued, 'test-only'), 'art' => 'Beratung', 'email' => ''];
+        $body = ['page' => 'kontakt', 'block' => 'f1', 'language' => 'en', 'issued' => (string) $issued, 'issuedSignature' => FormRepository::stamp('anfrage', $issued, 'test-only'), 'art' => 'Beratung', 'email' => ''];
        $refused = $this->request('/formular/anfrage', 'POST', $body);
        self::assertSame(422, $refused->getStatusCode());
        self::assertStringContainsString('This field is required.', (string) $refused->getContent());
Author	SHA1	Message	Date
kantarciandClaude Opus 5.5	daad5a1740	Release 1.32.1 CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 16:50:23 +02:00
kantarciandClaude Opus 5.5	dd5bc16413	Close the collapsible menu after choosing a link Same-page anchors kept the details menu open. scrolled.js closes it on any link click and loads only where a collapsible menu holds such links. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 16:50:23 +02:00
kantarciandClaude Opus 5.5	bb9d7c6b45	Note the 1.32.0 release in the status CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 16:32:24 +02:00
kantarciandClaude Opus 5.5	be4a4f23d8	Release 1.32.0 CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 16:31:07 +02:00
kantarciandClaude Opus 5.5	32e42f973b	Move site content between installations as a package System now exports a content package and imports one, by upload or from var/pakete. Pages with their revisions, areas, menus, media, forms, redirects, terms, translations, design and settings are replaced; submissions, statistics, tasks, plugin state and service keys stay, and accounts only come along when that is chosen explicitly. A backup comes first, the site is in maintenance meanwhile, and every file and document in the package is checked before anything is written. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 16:31:06 +02:00
kantarciandClaude Opus 5.5	a57b829a15	Note the 1.31.0 release in the status CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 16:07:28 +02:00
kantarciandClaude Opus 5.5	e465ec7437	Release 1.31.0 CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 16:06:15 +02:00
kantarciandClaude Opus 5.5	9e82918a5e	Close the open menu on a click beside it and add social icons The open burger menu now closes when someone clicks elsewhere, without a script: an invisible layer that belongs to the menu button covers the page while the menu is open. Facebook, Instagram and WhatsApp join the icon set, so menu buttons can carry them. The stroke attributes of every icon move into the stylesheet, which saves about 4 KB per page. Hüfner gets a right-aligned menu with the quote button, Facebook and Instagram as menu buttons. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 16:06:15 +02:00
kantarciandClaude Opus 5.5	3c5c50f499	Note the 1.30.0 release in the status CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 14:40:22 +02:00
kantarciandClaude Opus 5.5	c9c797e592	Release 1.30.0 CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 14:38:26 +02:00
kantarciandClaude Opus 5.5	ad7c333215	Harden KantSites after the security review - The installer only opens with a per-installation key that install.php creates and shows; the key is deleted with the first account. - Lock files keep .env, the database, backups and logs out of reach when a domain points at the project folder instead of public/. - Linked sections render by their own schema version, so an old section cannot carry unfiltered HTML into a newer page. - Editors no longer move, trash or change areas and post data of published pages; a scheduled publication goes live with the revision that was scheduled (migration 20261012000100). - Form stamps are bound to their form, IPv6 senders count per /64, and a flood per form or overall stops storing with a visible message. - The consent redirect rejects control characters, update targets must look like 1.2.3, and own CSS cannot reach outside its block. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 14:38:25 +02:00
kantarciandClaude Opus 5.5	14e7a3b310	Open Hüfner's outside links in a new tab and crop the tree for the favicon CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 14:03:03 +02:00
kantarciandClaude Opus 5.5	69f7977ecf	Note the 1.29.0 release in the status CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 13:57:31 +02:00
kantarciandClaude Opus 5.5	6f6e5d876c	Release 1.29.0 CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 13:56:16 +02:00
kantarciandClaude Opus 5.5	6fa303f901	Save consent without reloading the page consent.js posts the consent form in the background, the server answers 204 with the cookie, and the script swaps in the embeds and the legal line from a fresh copy of the page. Embed hosts are in frame-src from the start, the content address still only after consent. Without JavaScript the form keeps working with a reload. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 13:56:16 +02:00
kantarciandClaude Opus 5.5	6390c00876	Rework the Hüfner site after the customer meeting Tree green from the logo everywhere, the 100 emoji inline wherever 100 appears, downloads for the exemption certificates and the PQ certificate, the image video behind consent, Google reviews, a 48-hour quote promise, WhatsApp, two job cards and a page for the alpacas. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 13:56:16 +02:00
kantarciandClaude Opus 5.5	6ee05f4c70	Remove the duplicated 1.28.1 status entry CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 13:35:11 +02:00
kantarciandClaude Opus 5.5	1b6cbb2247	Note the 1.28.1 release in the status CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 13:34:58 +02:00
kantarciandClaude Opus 5.5	b298b7469f	Release 1.28.1 CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 13:33:31 +02:00
kantarciandClaude Opus 5.5	760efc3297	Stop the rewrite rule from looping on IONOS IONOS answered every rewritten address with a blank Apache 500: the !-f condition did not recognise the already rewritten index.php, so the rule fired again until Apache gave up. RewriteBase and an explicit stop for index.php, as in WordPress, fix it (ADR 114). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-12 13:33:31 +02:00
kantarciandClaude Opus 5.5	28070298aa	Note the 1.28.0 release in the status CMS quality / php (8.2) (push) Canceled after 0s Details CMS quality / php (8.4) (push) Canceled after 0s Details CMS quality / browser (push) Canceled after 0s Details CMS quality / mysql (push) Canceled after 0s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-09 18:46:20 +02:00
@@ -1 +1 @@
 .28.0
 .32.1