diff --git a/.gitignore b/.gitignore
index d3e3d48..7128a87 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,7 @@
*.log
/config/reference.php
/var/releases/
+
+# Schriften werden je Installation heruntergeladen, nicht mitgeliefert.
+/public/assets/fonts/
+/public/assets/build/
diff --git a/README.md b/README.md
index 1ed8f98..7d22785 100644
--- a/README.md
+++ b/README.md
@@ -79,6 +79,7 @@ composer build
npm.cmd ci
npx.cmd playwright install chromium
npm.cmd run test:browser
+npm.cmd run test:links
npm.cmd test
npm.cmd run test:editor
npm.cmd run test:editor -- --audit
@@ -89,7 +90,9 @@ Unter Linux/macOS `npm` und `npx` ohne `.cmd`; in CI `npx playwright install --w
`composer format` formatiert PHP. `composer build` wärmt den Symfony-Produktionscache; öffentliche CSS-Dateien sind direkt auslieferbar, es ist kein Frontend-Bundler nötig. Bei Änderungen an `public/assets/design-tokens.json` einmal `npm.cmd run build:design` ausführen und die erzeugte CSS-Datei mitliefern; Node ist auf dem Hosting nicht erforderlich. Nach Änderungen an Produktionskonfiguration/Templates `php bin/console cache:clear --env=prod --no-debug` ausführen. Falls lokale Tests alte Templates verwenden, vor PHPUnit auch `php bin/console cache:clear --env=test --no-debug` ausführen.
-Das Lighthouse-Skript misst die Startseite dreimal je Profil und prüft die Mediane gegen die Projektziele. `test:editor -- --audit` prüft die im isolierten Editortest gestaltete v3-Seite mit Abschnittsvorlage, Galerie, tatsächlichen Bildvarianten und Effekten; Berichte stehen unter `reports/lighthouse-editor`. Uploads und Datenbank des Tests liegen getrennt unter `var/browser-tests`. Diese kleinen Prototypseiten ersetzen nicht die spätere Referenzsuite mit Kundeninhalten, Fotos, Beitrag und Formular. Messgrenzen und Ergebnisse: `docs/QUALITY.md`.
+`test:links` folgt der Sitemap, sammelt jeden internen Verweis samt Bildern, Stylesheets und Hintergrundbildern und meldet jede Antwort ab 400 – gebaut, nachdem im Nachbau von kant-it.de vier Verweise ins Leere zeigten, die kein Test finden konnte.
+
+Das Lighthouse-Skript misst dreimal je Profil und prüft die Mediane gegen die Projektziele. Welche Adressen geprüft werden, sagt `CMS_PATHS` (mit Komma getrennt, Standard `/`); in der Git-Bash davor `MSYS_NO_PATHCONV=1` setzen, sonst wird aus `/` ein Windows-Pfad. `test:editor -- --audit` prüft die im isolierten Editortest gestaltete v3-Seite mit Abschnittsvorlage, Galerie, tatsächlichen Bildvarianten und Effekten; Berichte stehen unter `reports/lighthouse-editor`. Uploads und Datenbank des Tests liegen getrennt unter `var/browser-tests`. Diese kleinen Prototypseiten ersetzen nicht die spätere Referenzsuite mit Kundeninhalten, Fotos, Beitrag und Formular. Messgrenzen und Ergebnisse: `docs/QUALITY.md`.
## Inhalte und Entwicklung
diff --git a/bin/dev-router.php b/bin/dev-router.php
index 90293bd..d6a08f8 100644
--- a/bin/dev-router.php
+++ b/bin/dev-router.php
@@ -11,6 +11,38 @@
$path = parse_url($_SERVER['REQUEST_URI'] ?? '/', PHP_URL_PATH) ?: '/';
$file = __DIR__.'/../public'.$path;
if ('/' !== $path && !str_contains($path, '..') && is_file($file)) {
+ // Dieselben Antwortkoepfe wie public/.htaccess sie auf einem Webserver setzt: Stylesheets,
+ // Skripte, Schriften und Bilder tragen ihre Fassung oder ihre Kennung in der Adresse und
+ // duerfen deshalb lange im Browser bleiben. Ohne das misst jede Messung hier etwas anderes
+ // als das, was spaeter ausgeliefert wird - und man optimiert an der falschen Stelle.
+ if (1 === preg_match('/\.(css|js|woff2|webp|png|jpe?g|gif|svg)$/', $path, $treffer) && !str_starts_with($path, '/assets/seite/')) {
+ header('Content-Type: '.match ($treffer[1]) {
+ 'css' => 'text/css; charset=UTF-8',
+ 'js' => 'text/javascript; charset=UTF-8',
+ 'woff2' => 'font/woff2',
+ 'svg' => 'image/svg+xml; charset=UTF-8',
+ 'jpg', 'jpeg' => 'image/jpeg',
+ default => 'image/'.$treffer[1],
+ });
+ header('Cache-Control: public, max-age=31536000, immutable');
+ // Und ebenso die Komprimierung, die mod_deflate auf einem Webserver uebernimmt: ohne sie
+ // misst man hier eine Stylesheetgroesse, die es im Betrieb nie gibt.
+ $inhalt = (string) file_get_contents($file);
+ if (in_array($treffer[1], ['css', 'js', 'svg'], true) && str_contains($_SERVER['HTTP_ACCEPT_ENCODING'] ?? '', 'gzip')) {
+ $inhalt = (string) gzencode($inhalt, 6);
+ header('Content-Encoding: gzip');
+ header('Vary: Accept-Encoding');
+ }
+ header('Content-Length: '.strlen($inhalt));
+ echo $inhalt;
+
+ exit;
+ }
+
return false; // Let the built-in server deliver the static file.
}
+// Auch die Seiten selbst gehen komprimiert raus, wie auf einem Webserver mit mod_deflate.
+ini_set('zlib.output_compression', '1');
+ini_set('zlib.output_compression_level', '6');
+
require __DIR__.'/../public/index.php';
diff --git a/config/services.yaml b/config/services.yaml
index 04d3a9f..248132c 100644
--- a/config/services.yaml
+++ b/config/services.yaml
@@ -1,3 +1,10 @@
+parameters:
+ # Wo Schriften und Stylesheets liegen. Im Normalfall im oeffentlichen Ordner; ueber
+ # FONT_DIRECTORY und ASSET_DIRECTORY umstellbar - die Tests nutzen das, damit sie nicht in
+ # das Projekt schreiben, und eine Installation mit schreibgeschuetztem public/ ebenfalls.
+ kant.fonts_dir: '%kernel.project_dir%/public/assets/fonts'
+ kant.asset_dir: '%kernel.project_dir%/public/assets'
+
services:
_defaults:
autowire: true
@@ -15,6 +22,14 @@ services:
App\Content\MediaLibrary:
arguments:
$directory: '%env(resolve:MEDIA_DIRECTORY)%'
+ # Die Schriften liegen im oeffentlichen Ordner: sie sollen vom Webserver direkt ausgeliefert
+ # werden, ohne PHP dazwischen - das ist der Punkt der Uebung.
+ App\Content\FontLibrary:
+ arguments:
+ $directory: '%env(default:kant.fonts_dir:FONT_DIRECTORY)%'
+ App\Content\StyleBundle:
+ arguments:
+ $assetDirectory: '%env(default:kant.asset_dir:ASSET_DIRECTORY)%'
App\Controller\FormController:
arguments:
$secret: '%kernel.secret%'
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 163b836..a2a001d 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -450,6 +450,34 @@ Umut: „Hast du auch schon SEO und Siteindex usw. übernommen?“ Der Abgleich
**Kein Sitemap-Index.** Das Original liefert einen (drei Teilkarten von Yoast), KantSites eine einzelne Datei mit allen Adressen. Ein Index ist erst ab 50.000 Adressen oder 50 MB vorgeschrieben; bei 35 Adressen wäre er eine Datei mehr ohne jeden Unterschied für eine Suchmaschine. Aufgeteilt wird, wenn es eine Website gibt, die das braucht – und dann automatisch, nicht als Einstellung.
+## ADR 058 – Bilder in der Größe, in der sie erscheinen (13.09.2026)
+
+Gemessen auf der nachgebauten Startseite: ein Telefon lud das Hintergrundbild des Hero mit **1920 Pixeln und 189 KB**. Zu sehen war davon nie mehr als ein Viertel. Die Ursache ist bauartbedingt: wer im Editor ein Hintergrundbild wählt, sitzt am Schreibtisch und setzt es unter „Desktop“; kleine Geräte erben diese Regel, und CSS kennt kein `srcset`.
+
+Die Regeln stehen aber ohnehin je Gerät da. Der Kompilierer ergänzt deshalb für Tablet und Telefon dieselbe Bildwahl, die entstünde, wenn jemand sie einzeln gesetzt hätte – samt Verlauf und Abdunkelung, denn ohne sie stünde heller Text plötzlich auf einem ungedämpften Bild. Ein ausdrücklich gesetztes Bild wird nie ersetzt. **189 KB → 40 KB auf dem Telefon.**
+
+Dasselbe Thema bei ``: jedes Bild behauptete, 800 Pixel breit zu erscheinen – auch ein Logo, das 190 Pixel breit ist. Jetzt gilt: eine im Block gesetzte feste Breite ist die Antwort; sonst steht bei verzögert geladenen Bildern `sizes="auto"`, womit der Browser selbst nachmisst (Rückfallangaben dahinter für Safari). Das vorgezogene Bild behält die Annahme, weil seine Größe zum Zeitpunkt der Anfrage noch nicht feststeht.
+
+Und die Eile lag auf der falschen Stelle: `fetchpriority="high"` bekam das erste Bild überhaupt – das Logo im Kopfbereich. Es bekommt es jetzt das erste Bild im **ersten Abschnitt des Inhalts**; Bilder im Kopfbereich laden weiterhin sofort, aber ohne Vorrang.
+
+**Was nicht blieb:** ein Vorabladen des Hero-Hintergrunds (``). Der Gedanke stimmt – ein Bild im Stylesheet wird spät entdeckt –, die Messung nicht: mobil **95 → 90**. Das Bild nimmt genau die Bandbreite weg, die der Text für den größten Aufbauschritt braucht. Wieder entfernt.
+
+## ADR 057 – Schriften vom eigenen Server (13.09.2026)
+
+Eine Schrift von `fonts.googleapis.com` kostet zweierlei. Technisch: der Browser holt erst das Stylesheet, findet darin die Adresse der Schriftdatei und holt dann diese – zwei fremde Verbindungen nacheinander, gemessen 820 ms, in denen keine Zeile in der richtigen Schrift steht. Rechtlich: ein Dritter erfährt die IP-Adresse jedes Besuchers, und dafür gibt es in Deutschland Abmahnungen (LG München I, 3 O 17493/20).
+
+Deshalb: **einmal holen, selbst ausliefern.** Ein Knopf im Designbereich (und `cms:fonts:fetch` auf der Konsole) lädt die gewählten Schnitte als WOFF2 nach `public/assets/fonts`, schreibt die `@font-face`-Regeln daneben und meldet, was geladen wurde. Die Lizenz erlaubt das ausdrücklich – Google Fonts stehen unter OFL oder Apache 2.0.
+
+Drei Entscheidungen dabei: **Kein neues Paket** – geholt wird mit curl, ersatzweise über `allow_url_fopen`, genau wie der Installer es tut; eine zusätzliche Abhängigkeit würde jedes Update auf einem Hosting ohne Composer scheitern lassen. **Nur Latein** – Kyrillisch und Vietnamesisch wären zwei Drittel der Bytes für nichts. **Nicht beim Seitenaufruf** – ein Besucher wartet nie auf einen fremden Server, auch nicht mittelbar. Liegen die Dateien nicht, bleibt es beim Verweis auf Google statt einer Seite ohne Schrift.
+
+## ADR 056 – Vier Stylesheets werden eines, und der Webserver bekommt Anweisungen (13.09.2026)
+
+Vor dem Livegang gemessen, nicht geschätzt. Jede der vier CSS-Dateien hält das Zeichnen der Seite auf, zusammen 46 KB. Sie sind getrennt, weil sie beim Schreiben Verschiedenes tun; beim Ausliefern ist das kein Argument. Ein Bündel trägt die Prüfsumme seines Inhalts im Namen, wird beim ersten Aufruf nach einer Änderung erzeugt und ohne Kommentare geschrieben. Minifiziert wird bewusst nur das: Kommentare und Einrückung. Ein Minifier, der Selektoren umbaut, spart Zeichen und kostet einen Abend Fehlersuche – in `calc(100% - 20px)` und `.a :hover` trägt ein Leerzeichen Bedeutung. Fehlt das Schreibrecht, werden die Quellen einzeln geladen: langsamer, aber heil.
+
+Dazu eine `public/.htaccess`, die diesen Namen verdient: Kompression (mod_deflate/mod_brotli), ein Jahr Cache für alles, was seine Fassung oder Kennung in der Adresse trägt – Stylesheets und Skripte bekommen dafür `?v=` mit der Programmfassung –, und ein Riegel vor Dateien, die niemanden angehen. HTTPS-Umleitung und HSTS stehen auskommentiert mit dem Grund dabei: eine Umleitung ohne Zertifikat ist eine Endlosschleife, und HSTS lässt sich ein halbes Jahr lang nicht zurücknehmen.
+
+**Der Entwicklungsserver sendet jetzt dieselben Kopfzeilen und komprimiert ebenso.** Ohne das misst man hier Größen, die es im Betrieb nie gibt: dieselbe Startseite ging von 90 auf 96 Punkte, ohne dass sich an ihr etwas geändert hätte.
+
## ADR 055 – Das Symbol der Website entsteht aus einem Bild der Mediathek (13.09.2026)
Umut: „dann brauchen wir Favicon-Möglichkeit zum Festlegen“. Ein Favicon ist der einzige Teil der Gestaltung, den ein Besucher sieht, bevor die Seite geladen ist – und bisher war es das mitgelieferte Zeichen, für jede mit KantSites gebaute Website dasselbe.
diff --git a/docs/STATUS.md b/docs/STATUS.md
index c5aadbd..2ea7fc3 100644
--- a/docs/STATUS.md
+++ b/docs/STATUS.md
@@ -32,6 +32,12 @@ Erster Commit angelegt (`82b0782`); das Projekt hat damit einen Rückfallpunkt.
- **Ladeverhalten gemessen statt vermutet** (ADR 039, Arbeitspaket M): ein Zähler liefert die Datenbankabfragen je Anfrage im Kopf `X-Kant-Queries` (außerhalb der Produktion). Die erste Messung zeigte 18 Abfragen auf der Startseite, weil Einstellungen und Theme je Aufrufer erneut gelesen wurden; beide merken sich ihren Stand jetzt für die Dauer einer Anfrage – **18 → 8**. Die Browserprüfung misst je Seite HTML, CSS, Anfragen, Skripte und Abfragen gegen Obergrenzen: Startseite 7,4 KB HTML, 22,7 KB CSS, 2 Anfragen, 0 Skripte.
- **Das erste Bild einer Seite lädt sofort**, alles darunter weiterhin verzögert. Es ist meistens das größte Ding über der Falz.
- **Slider mit Punkten ohne Skript** (ADR 044): `::scroll-marker` zeichnet je Folie einen Punkt, der aktive ist erkennbar, die Rollleiste entfällt; ältere Browser behalten das wischbare Schiebefeld. Beitragskarten sind echte Karten (Bild 16:10, 18 px Ecken). Überschriften dürfen ein Wort hervorheben (``, in Akzentfarbe). Behoben: die Theme-Schriftskala überschrieb die Größen in Karten und Aufruf-Bändern.
+- **Getrennter Titel für Suchergebnisse** (Migration `20260913000100`): jede Seite und jeder Beitrag kann einen eigenen `` tragen, unabhängig von der Überschrift auf der Seite. Leer heißt weiterhin: der Titel der Seite gilt. Er zählt auch für `og:title`.
+- **Schriften kommen vom eigenen Server** (ADR 057): ein Knopf im Designbereich oder `php bin/console cms:fonts:fetch` lädt die gewählten Google-Schnitte als WOFF2 nach `public/assets/fonts` und schreibt die `@font-face`-Regeln daneben. Damit lädt keine Seite mehr etwas von Google – das spart zwei fremde Verbindungen nacheinander (gemessen 820 ms) und die datenschutzrechtliche Angreifbarkeit gleich mit. Ohne Dateien bleibt es beim bisherigen Verweis.
+- **Ein Stylesheet statt vier, und eine `.htaccess`, die etwas tut** (ADR 056): gebündelt, ohne Kommentare, mit Prüfsumme im Dateinamen; Kompression, ein Jahr Cache für Dateien mit Fassung oder Kennung in der Adresse, Schutz vor dem Ausliefern interner Dateien, HTTPS-Umleitung und HSTS vorbereitet und auskommentiert. Der Entwicklungsserver sendet dieselben Kopfzeilen, damit lokale Messungen etwas bedeuten.
+- **Bilder in der Größe, in der sie erscheinen** (ADR 058): ein Hintergrundbild, das nur für „Desktop“ gesetzt wurde, gilt auf dem Telefon in der Telefongröße (gemessen 189 KB → 40 KB); `<img>` nennt seine feste Breite, wenn es eine hat, und sonst `sizes="auto"`; `fetchpriority="high"` liegt auf dem ersten Bild des Inhalts statt auf dem Logo im Kopfbereich.
+- **Lighthouse gegen den Nachbau von kant-it.de** (`docs/quality/lighthouse-kantit.json`, vier Adressen, je drei Läufe, Median): Barrierefreiheit, Best Practices, SEO und „agentic browsing“ **100 auf allen geprüften Seiten, mobil wie am Schreibtisch**. Performance: Projekte-, Beitrags- und Impressumsseite **100/100**, Startseite **98 mobil / 96 am Schreibtisch** – dort liegen vier Sliderbilder und ein großflächiges Hintergrundbild über der Falz. Gemessen im Produktionsmodus mit denselben Kopfzeilen, die `public/.htaccess` setzt; keine Felddaten und keine Messung auf echtem Hosting.
+- **Verweise werden geprüft** (`npm run test:links`): folgt der Sitemap, sammelt jeden internen Verweis samt Bildern, Stylesheets und Hintergrundbildern und meldet jede Antwort ab 400. Im Nachbau 408 Adressen, kein toter Verweis.
- **Das Vorschaubild beim Teilen erscheint jetzt tatsächlich** (ADR 056): `og:image` wird aus dem Feld der Seite aufgelöst, ersatzweise aus dem Beitragsbild – vorher speicherte das Feld und bewirkte nichts, keine KantSites-Seite hatte ein Teilen-Bild. Dazu `og:site_name`, `og:locale`, `og:image:alt`, `twitter:card` (klein ohne Bild, groß mit) und das Bild im strukturierten Datensatz eines Beitrags. Archive haben jetzt ebenfalls Open-Graph-Angaben.
- **Eigene robots.txt-Zeilen: 200 statt 30, Leerzeilen bleiben** (ADR 056), damit sich Regeln je Bot in Blöcken schreiben lassen – etwa welche KI-Crawler lesen dürfen. Ein Sitemap-Index ist bewusst nicht gebaut: nötig wird er ab 50.000 Adressen.
- **Beiträge sind optional** (ADR 053): ohne einen einzigen veröffentlichten Beitrag antworten `/beitraege` und `/feed.xml` mit 404, der Feedverweis fehlt im Kopf, die Sitemap kennt kein Archiv, und ein Beitragslisten-Baustein zeigt öffentlich nichts – der Hinweis „hier erscheinen Beiträge“ bleibt nur im Editor. Ein Kategorie- oder Schlagwortarchiv verschwindet ebenso, sobald es nichts mehr zu zeigen hat; der Begriff selbst bleibt. Dabei behoben: die Beitragsliste fragte je Beitrag einzeln nach Bild und Begriffen – jetzt je eine Abfrage für die ganze Liste, Startseite des Nachbaus **22 → 16 Abfragen**.
diff --git a/docs/quality/lighthouse-kantit.json b/docs/quality/lighthouse-kantit.json
new file mode 100644
index 0000000..183b6a6
--- /dev/null
+++ b/docs/quality/lighthouse-kantit.json
@@ -0,0 +1,106 @@
+[
+ {
+ "path": "/",
+ "profile": "mobile",
+ "scores": {
+ "performance": 0.98,
+ "accessibility": 1,
+ "best-practices": 1,
+ "seo": 1,
+ "agentic-browsing": 1
+ },
+ "lighthouseVersion": "13.4.1",
+ "note": "Lokale Messung gegen den Nachbau von kant-it.de im Produktionsmodus, PHP-Entwicklungsserver mit denselben Kopfzeilen wie public/.htaccess. Keine Felddaten."
+ },
+ {
+ "path": "/",
+ "profile": "desktop",
+ "scores": {
+ "performance": 0.96,
+ "accessibility": 1,
+ "best-practices": 1,
+ "seo": 1,
+ "agentic-browsing": 1
+ },
+ "lighthouseVersion": "13.4.1",
+ "note": "Lokale Messung gegen den Nachbau von kant-it.de im Produktionsmodus, PHP-Entwicklungsserver mit denselben Kopfzeilen wie public/.htaccess. Keine Felddaten."
+ },
+ {
+ "path": "/projekte",
+ "profile": "mobile",
+ "scores": {
+ "performance": 1,
+ "accessibility": 1,
+ "best-practices": 1,
+ "seo": 1,
+ "agentic-browsing": 1
+ },
+ "lighthouseVersion": "13.4.1",
+ "note": "Lokale Messung gegen den Nachbau von kant-it.de im Produktionsmodus, PHP-Entwicklungsserver mit denselben Kopfzeilen wie public/.htaccess. Keine Felddaten."
+ },
+ {
+ "path": "/projekte",
+ "profile": "desktop",
+ "scores": {
+ "performance": 1,
+ "accessibility": 1,
+ "best-practices": 1,
+ "seo": 1,
+ "agentic-browsing": 1
+ },
+ "lighthouseVersion": "13.4.1",
+ "note": "Lokale Messung gegen den Nachbau von kant-it.de im Produktionsmodus, PHP-Entwicklungsserver mit denselben Kopfzeilen wie public/.htaccess. Keine Felddaten."
+ },
+ {
+ "path": "/simplescan",
+ "profile": "mobile",
+ "scores": {
+ "performance": 1,
+ "accessibility": 1,
+ "best-practices": 1,
+ "seo": 1,
+ "agentic-browsing": 1
+ },
+ "lighthouseVersion": "13.4.1",
+ "note": "Lokale Messung gegen den Nachbau von kant-it.de im Produktionsmodus, PHP-Entwicklungsserver mit denselben Kopfzeilen wie public/.htaccess. Keine Felddaten."
+ },
+ {
+ "path": "/simplescan",
+ "profile": "desktop",
+ "scores": {
+ "performance": 1,
+ "accessibility": 1,
+ "best-practices": 1,
+ "seo": 1,
+ "agentic-browsing": 1
+ },
+ "lighthouseVersion": "13.4.1",
+ "note": "Lokale Messung gegen den Nachbau von kant-it.de im Produktionsmodus, PHP-Entwicklungsserver mit denselben Kopfzeilen wie public/.htaccess. Keine Felddaten."
+ },
+ {
+ "path": "/impressum",
+ "profile": "mobile",
+ "scores": {
+ "performance": 1,
+ "accessibility": 1,
+ "best-practices": 1,
+ "seo": 1,
+ "agentic-browsing": 1
+ },
+ "lighthouseVersion": "13.4.1",
+ "note": "Lokale Messung gegen den Nachbau von kant-it.de im Produktionsmodus, PHP-Entwicklungsserver mit denselben Kopfzeilen wie public/.htaccess. Keine Felddaten."
+ },
+ {
+ "path": "/impressum",
+ "profile": "desktop",
+ "scores": {
+ "performance": 1,
+ "accessibility": 1,
+ "best-practices": 1,
+ "seo": 1,
+ "agentic-browsing": 1
+ },
+ "lighthouseVersion": "13.4.1",
+ "note": "Lokale Messung gegen den Nachbau von kant-it.de im Produktionsmodus, PHP-Entwicklungsserver mit denselben Kopfzeilen wie public/.htaccess. Keine Felddaten."
+ }
+]
diff --git a/migrations/Version20260913000100.php b/migrations/Version20260913000100.php
new file mode 100644
index 0000000..cbbc81f
--- /dev/null
+++ b/migrations/Version20260913000100.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+final class Version20260913000100 extends AbstractMigration
+{
+ public function getDescription(): string
+ {
+ return 'A separate title for search results, independent of the page title.';
+ }
+
+ public function isTransactional(): bool
+ {
+ return false;
+ }
+
+ public function up(Schema $schema): void
+ {
+ // Der Titel in der Suche muss nicht der Titel der Seite sein: auf der Seite steht
+ // "Leistungen", im Suchergebnis hilft "IT-Leistungen für Mittelbaden – Kant-IT". NULL
+ // heisst: der Titel des Dokuments gilt, wie bisher.
+ $schema->getTable('page')->addColumn('seo_title', 'string', ['length' => 160, 'notnull' => false]);
+ }
+
+ public function down(Schema $schema): void
+ {
+ $this->throwIrreversibleMigrationException('Dropping this would silently discard every title written for search results. Restore a verified backup with matching code.');
+ }
+}
diff --git a/package.json b/package.json
index 3c2c290..1149d35 100644
--- a/package.json
+++ b/package.json
@@ -7,6 +7,7 @@
"test": "node --test tests/*.test.mjs",
"test:editor": "node scripts/editor-check.mjs",
"test:browser": "node scripts/browser-check.mjs",
+ "test:links": "node scripts/link-check.mjs",
"audit": "node scripts/audit.mjs"
},
"devDependencies": {
diff --git a/public/.htaccess b/public/.htaccess
index d221f02..2e0a85f 100644
--- a/public/.htaccess
+++ b/public/.htaccess
@@ -1,5 +1,65 @@
DirectoryIndex index.php
Options -Indexes -MultiViews
+
+# Alles, was keine Datei ist, beantwortet PHP.
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^ index.php [L]
+
+# HTTPS erzwingen. Auskommentiert, weil diese Datei auch in Installationen ohne Zertifikat
+# liegt und eine Endlosschleife schlimmer waere als fehlendes HTTPS. Vor dem Livegang mit
+# Zertifikat: die drei Zeilen einschalten - und erst danach die HSTS-Zeile weiter unten,
+# denn HSTS laesst sich in einem Browser ein halbes Jahr lang nicht zuruecknehmen.
+#RewriteCond %{HTTPS} !=on
+#RewriteCond %{HTTP:X-Forwarded-Proto} !=https
+#RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L]
+
+# Uebertragen wird komprimiert. HTML, CSS, JavaScript und XML schrumpfen dabei auf etwa ein
+# Viertel; Bilder und Schriften sind bereits komprimiert und bleiben aussen vor.
+<IfModule mod_deflate.c>
+ AddOutputFilterByType DEFLATE text/html text/plain text/xml text/css
+ AddOutputFilterByType DEFLATE application/javascript application/json application/xml
+ AddOutputFilterByType DEFLATE application/rss+xml image/svg+xml
+</IfModule>
+<IfModule mod_brotli.c>
+ AddOutputFilterByType BROTLI_COMPRESS text/html text/css application/javascript image/svg+xml
+</IfModule>
+
+# Wie lange ein Browser eine Datei behalten darf.
+#
+# Bilder und Schriften tragen ihre Kennung im Namen: aendert sich der Inhalt, aendert sich die
+# Adresse. Sie duerfen deshalb ein Jahr bleiben. Stylesheets und Skripte tragen die Fassung als
+# Parameter, also ebenfalls ein Jahr. HTML wird nie zwischengespeichert - eine veroeffentlichte
+# Aenderung soll beim naechsten Aufruf sichtbar sein; die Seiten senden dafuer selbst no-store.
+<IfModule mod_expires.c>
+ ExpiresActive On
+ ExpiresByType image/webp "access plus 1 year"
+ ExpiresByType image/png "access plus 1 year"
+ ExpiresByType image/jpeg "access plus 1 year"
+ ExpiresByType image/svg+xml "access plus 1 year"
+ ExpiresByType font/woff2 "access plus 1 year"
+ ExpiresByType text/css "access plus 1 year"
+ ExpiresByType application/javascript "access plus 1 year"
+</IfModule>
+<IfModule mod_headers.c>
+ <FilesMatch "\.(webp|png|jpe?g|gif|svg|woff2|css|js)$">
+ Header set Cache-Control "public, max-age=31536000, immutable"
+ </FilesMatch>
+ # Schriften werden von derselben Adresse geladen; die Regel steht hier, damit sie auch dann
+ # gilt, wenn eine Installation die Dateien ueber ein CDN spiegelt.
+ <FilesMatch "\.woff2$">
+ Header set Access-Control-Allow-Origin "*"
+ </FilesMatch>
+ # Erst einschalten, wenn HTTPS steht und bleiben soll (siehe oben).
+ #Header always set Strict-Transport-Security "max-age=31536000; includeSubDomains"
+</IfModule>
+
+# Nichts ausliefern, was nur intern gebraucht wird - falls jemand das Paket versehentlich
+# vollstaendig in den oeffentlichen Ordner legt statt nur public/.
+<FilesMatch "^\.|\.(env|db|sqlite|lock|md|yaml|yml|dist|log)$">
+ Require all denied
+</FilesMatch>
+# Eine Ausnahme mit Grund: der Editor liest die Liste der Gestaltungswerte als JSON.
+<Files "design-tokens.json">
+ Require all granted
+</Files>
diff --git a/scripts/audit.mjs b/scripts/audit.mjs
index 9198c83..242f163 100644
--- a/scripts/audit.mjs
+++ b/scripts/audit.mjs
@@ -5,6 +5,9 @@ import { mkdir, writeFile } from 'node:fs/promises';
import net from 'node:net';
const origin = process.env.CMS_URL || 'http://127.0.0.1:8080';
+// Eine Startseite ist nicht die Website. Geprüft wird, was CMS_PATHS nennt - mehrere Adressen mit
+// Komma getrennt; ohne Angabe die Startseite.
+const paths = (process.env.CMS_PATHS || '/').split(',').map(p => p.trim()).filter(Boolean);
const output = process.env.CMS_AUDIT_DIR || 'reports/lighthouse';
const preflight = await fetch(origin);
if (!preflight.ok || /noindex/i.test(preflight.headers.get('x-robots-tag') || '')) {
@@ -18,10 +21,12 @@ await new Promise(resolve => portProbe.close(resolve));
const chrome = await chromium.launch({ args: [`--remote-debugging-port=${port}`] });
const summary = [];
try {
+ for (const path of paths) {
+ const label = '/' === path ? 'home' : path.replace(/^\//, '').replace(/\//g, '-');
for (const profile of ['mobile', 'desktop']) {
const runs = [];
for (let run = 1; run <= 3; run++) {
- const result = await lighthouse(origin, {
+ const result = await lighthouse(origin + ('/' === path ? '' : path), {
port,
output: 'json',
logLevel: 'error',
@@ -30,18 +35,22 @@ try {
if (lhr.configSettings.formFactor !== profile) {
throw new Error(`Requested ${profile}, measured ${lhr.configSettings.formFactor}`);
}
- await writeFile(`${output}/${profile}-${run}.json`, result.report);
+ await writeFile(`${output}/${label}-${profile}-${run}.json`, result.report);
runs.push(lhr);
- console.log(profile, run, Object.fromEntries(Object.entries(lhr.categories).map(([key, value]) => [key, value.score])));
+ console.log(label, profile, run, Object.fromEntries(Object.entries(lhr.categories).map(([key, value]) => [key, value.score])));
}
const scores = {};
for (const category of Object.keys(runs[0].categories)) {
const values = runs.map(r => r.categories[category].score).filter(v => v !== null).sort((a, b) => a - b);
scores[category] = values.length ? values[Math.floor(values.length / 2)] : null;
}
- summary.push({ profile, scores, lighthouseVersion: runs[0].lighthouseVersion, settings: runs[0].configSettings, environment: runs[0].environment, note: 'Local prototype only. No customer-site acceptance or field-data claim.' });
+ summary.push({ path, profile, scores, lighthouseVersion: runs[0].lighthouseVersion, settings: runs[0].configSettings, environment: runs[0].environment, note: 'Local prototype only. No customer-site acceptance or field-data claim.' });
+ }
}
await writeFile(`${output}/summary.json`, JSON.stringify(summary, null, 2));
+ for (const row of summary) {
+ console.log(`${row.path} ${row.profile}: ${Object.entries(row.scores).map(([k, v]) => k + ' ' + Math.round(v * 100)).join(', ')}`);
+ }
const passed = summary.every(r => r.scores.performance >= .95 && ['accessibility', 'best-practices', 'seo'].every(c => r.scores[c] === 1) && (r.scores['agentic-browsing'] === undefined || r.scores['agentic-browsing'] === 1));
if (!passed) process.exitCode = 1;
} finally {
diff --git a/scripts/link-check.mjs b/scripts/link-check.mjs
new file mode 100644
index 0000000..774bd6e
--- /dev/null
+++ b/scripts/link-check.mjs
@@ -0,0 +1,102 @@
+/*
+ * Prüft jeden internen Verweis einer Website auf seine Antwort.
+ *
+ * Ein Link, der ins Leere zeigt, ist der Fehler, den niemand bemerkt: Tests prüfen, was der Code
+ * erzeugt, nicht ob die Adresse dahinter existiert. Im Nachbau von kant-it.de zeigten vier
+ * Verweise im Hero-Slider auf Adressen, die es nie gab - gefunden hat das kein Test, sondern ein
+ * Durchlauf wie dieser.
+ *
+ * Ausgangspunkt ist die Sitemap, danach wird jeder Seite gefolgt, die von dort erreichbar ist.
+ * Geprüft werden Seiten, Bilder, Stylesheets und Skripte; externe Adressen werden gezählt, aber
+ * nicht abgerufen - ob fremde Server antworten, ist nicht die Frage dieser Prüfung.
+ *
+ * CMS_URL=http://127.0.0.1:8080 npm run test:links
+ */
+import { chromium } from 'playwright';
+import assert from 'node:assert/strict';
+import { mkdir, writeFile } from 'node:fs/promises';
+
+const origin = (process.env.CMS_URL || 'http://127.0.0.1:8080').replace(/\/$/, '');
+const browser = await chromium.launch();
+const geprueft = new Map();
+const extern = new Set();
+const kaputt = [];
+const quellen = new Map();
+
+try {
+ const context = await browser.newContext();
+ const page = await context.newPage();
+
+ const antwort = async (url) => {
+ if (!geprueft.has(url)) {
+ const response = await context.request.get(url, { maxRedirects: 5 });
+ geprueft.set(url, response.status());
+ }
+
+ return geprueft.get(url);
+ };
+
+ const sitemap = await context.request.get(origin + '/sitemap.xml');
+ assert.equal(sitemap.status(), 200, 'Ohne Sitemap fehlt der Ausgangspunkt.');
+ const seiten = [...(await sitemap.text()).matchAll(/<loc>([^<]+)<\/loc>/g)]
+ .map(treffer => new URL(treffer[1]).pathname);
+ console.log(`Sitemap: ${seiten.length} Adresse(n).`);
+
+ const besucht = new Set();
+ const warteschlange = ['/', ...seiten];
+ while (warteschlange.length > 0) {
+ const pfad = warteschlange.shift();
+ if (besucht.has(pfad)) continue;
+ besucht.add(pfad);
+
+ const response = await page.goto(origin + pfad, { waitUntil: 'domcontentloaded' });
+ if (200 !== response.status()) {
+ kaputt.push({ status: response.status(), url: pfad, von: 'Sitemap' });
+ continue;
+ }
+ // Verweise und eingebundene Dateien derselben Website.
+ const verweise = await page.evaluate(() => ({
+ links: [...document.querySelectorAll('a[href]')].map(a => a.getAttribute('href')),
+ dateien: [
+ ...[...document.querySelectorAll('img[src]')].map(i => i.getAttribute('src')),
+ ...[...document.querySelectorAll('img[srcset]')].flatMap(i => i.getAttribute('srcset').split(',').map(teil => teil.trim().split(/\s+/)[0])),
+ ...[...document.querySelectorAll('link[rel="stylesheet"], link[rel="preload"]')].map(l => l.getAttribute('href')),
+ ...[...document.querySelectorAll('script[src]')].map(s => s.getAttribute('src')),
+ ...[...document.querySelectorAll('[style*="url("]')].flatMap(e => [...e.getAttribute('style').matchAll(/url\(["']?([^"')]+)/g)].map(m => m[1])),
+ ],
+ stile: [...document.querySelectorAll('style')].flatMap(s => [...s.textContent.matchAll(/url\(["']?([^"')]+)/g)].map(m => m[1])),
+ }));
+
+ for (const roh of [...verweise.links, ...verweise.dateien, ...verweise.stile]) {
+ if (!roh || roh.startsWith('data:') || roh.startsWith('#') || roh.startsWith('mailto:') || roh.startsWith('tel:')) continue;
+ const ziel = new URL(roh, origin + pfad);
+ if (ziel.origin !== origin) {
+ extern.add(ziel.origin);
+ continue;
+ }
+ const adresse = ziel.pathname + ziel.search;
+ const status = await antwort(origin + adresse);
+ if (status >= 400) {
+ kaputt.push({ status, url: adresse, von: pfad });
+ }
+ // Eigenen Seiten folgen wir weiter; Dateien nicht.
+ if (verweise.links.includes(roh) && !/\.[a-z0-9]{2,5}(\?|$)/i.test(ziel.pathname) && !besucht.has(ziel.pathname)) {
+ warteschlange.push(ziel.pathname);
+ quellen.set(ziel.pathname, pfad);
+ }
+ }
+ }
+
+ await mkdir('reports', { recursive: true });
+ await writeFile('reports/links.json', JSON.stringify({ origin, geprueft: geprueft.size, seiten: besucht.size, extern: [...extern], kaputt }, null, 2));
+ console.log(`${besucht.size} Seite(n), ${geprueft.size} Adresse(n) geprüft, ${extern.size} fremde Quelle(n): ${[...extern].join(', ') || 'keine'}`);
+ if (kaputt.length > 0) {
+ for (const eintrag of kaputt) {
+ console.error(` ${eintrag.status} ${eintrag.url} (verlinkt auf ${eintrag.von})`);
+ }
+ throw new Error(`${kaputt.length} Verweis(e) zeigen ins Leere.`);
+ }
+ console.log('Kein toter Verweis.');
+} finally {
+ await browser.close();
+}
diff --git a/src/Command/FetchFontsCommand.php b/src/Command/FetchFontsCommand.php
new file mode 100644
index 0000000..d67bc4d
--- /dev/null
+++ b/src/Command/FetchFontsCommand.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Command;
+
+use App\Content\FontLibrary;
+use App\Content\Theme;
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+/**
+ * Holt die Schriften des Designs auf den eigenen Server.
+ *
+ * Dasselbe wie der Knopf im Designbereich, für Installationen mit Konsolenzugang - und für den
+ * Fall, dass eine frisch aufgesetzte Website die Dateien noch nicht hat.
+ */
+#[AsCommand(name: 'cms:fonts:fetch', description: 'Lädt die Google-Schriften des Designs nach public/assets/fonts.')]
+final class FetchFontsCommand extends Command
+{
+ public function __construct(private Theme $theme, private FontLibrary $fonts)
+ {
+ parent::__construct();
+ }
+
+ protected function execute(InputInterface $input, OutputInterface $output): int
+ {
+ $io = new SymfonyStyle($input, $output);
+ try {
+ $result = $this->fonts->fetch($this->theme->load());
+ } catch (\RuntimeException $error) {
+ $io->error($error->getMessage());
+
+ return Command::FAILURE;
+ }
+ $io->success(sprintf(
+ '%d Datei(en) geladen, %d KB insgesamt: %s. Die Seiten laden jetzt nichts mehr von Google.',
+ $result['files'],
+ (int) round($result['bytes'] / 1024),
+ implode(', ', $result['families']),
+ ));
+
+ return Command::SUCCESS;
+ }
+}
diff --git a/src/Content/FontLibrary.php b/src/Content/FontLibrary.php
new file mode 100644
index 0000000..6286b35
--- /dev/null
+++ b/src/Content/FontLibrary.php
@@ -0,0 +1,272 @@
+<?php
+
+namespace App\Content;
+
+/**
+ * Schriften, die die Website selbst ausliefert.
+ *
+ * Eine Schrift von fonts.googleapis.com kostet zweierlei. Technisch: der Browser muss erst das
+ * Stylesheet holen, darin die Adresse der Schriftdatei finden und dann diese holen - zwei fremde
+ * Verbindungen hintereinander, bevor die erste Zeile in der richtigen Schrift steht. Rechtlich:
+ * dabei erfährt ein Dritter die IP-Adresse jedes Besuchers, und dafür gibt es in Deutschland
+ * Abmahnungen (LG München I, 3 O 17493/20).
+ *
+ * Beides verschwindet, wenn die Dateien auf dem eigenen Server liegen. Die Lizenz erlaubt das:
+ * die Schriften bei Google Fonts stehen unter der SIL Open Font License oder Apache 2.0.
+ *
+ * Heruntergeladen wird einmal auf Zuruf, nicht bei einem Seitenaufruf - ein Besucher soll nie auf
+ * einen fremden Server warten, auch nicht mittelbar.
+ */
+final class FontLibrary
+{
+ /**
+ * Der Browser, als den wir uns ausgeben.
+ *
+ * Google liefert je nach Browser ein anderes Stylesheet: alten Browsern TTF, neuen WOFF2. Ohne
+ * diese Kennung bekämen wir Dateien, die viermal so groß sind.
+ */
+ private const AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36';
+
+ /** Zeichenbereiche, die eine deutschsprachige Website braucht. Kyrillisch und Vietnamesisch nicht. */
+ private const SUBSETS = ['latin', 'latin-ext'];
+
+ public function __construct(private string $directory)
+ {
+ }
+
+ /** Liegen für dieses Theme fertige Dateien bereit? */
+ public function hasLocal(array $theme): bool
+ {
+ return [] === $this->missing($theme) && is_file($this->directory.'/fonts.css');
+ }
+
+ /**
+ * Die Schriften des Themes, für die noch keine lokale Datei existiert.
+ *
+ * @return list<string> Beschriftungen wie „Lato 700“
+ */
+ public function missing(array $theme): array
+ {
+ $missing = [];
+ foreach ($this->wanted($theme) as $family => $weights) {
+ foreach ($weights as $weight) {
+ if ([] === glob($this->directory.'/'.$this->slug($family).'-'.$weight.'-*.woff2')) {
+ $missing[] = $family.' '.$weight;
+ }
+ }
+ }
+
+ return $missing;
+ }
+
+ /**
+ * Holt alle Schriften des Themes und schreibt fonts.css daneben.
+ *
+ * @return array{files: int, bytes: int, families: list<string>}
+ */
+ public function fetch(array $theme): array
+ {
+ $wanted = $this->wanted($theme);
+ if ([] === $wanted) {
+ throw new \RuntimeException('Dieses Design nutzt keine Schrift von Google Fonts.');
+ }
+ if (!is_dir($this->directory) && !mkdir($this->directory, 0775, true) && !is_dir($this->directory)) {
+ throw new \RuntimeException('Der Schriftenordner ist nicht beschreibbar: '.$this->directory);
+ }
+ $rules = [];
+ $files = 0;
+ $bytes = 0;
+ foreach ($wanted as $family => $weights) {
+ $css = $this->stylesheet($family, $weights);
+ foreach ($this->parse($css, $family) as $face) {
+ $name = $this->slug($family).'-'.$face['weight'].'-'.$face['subset'].'.woff2';
+ $path = $this->directory.'/'.$name;
+ if (!is_file($path)) {
+ file_put_contents($path, $this->download($face['url']));
+ ++$files;
+ }
+ $bytes += (int) filesize($path);
+ $rules[] = sprintf(
+ "/* %s */\n@font-face{font-family:'%s';font-style:%s;font-weight:%d;font-display:swap;src:url(/assets/fonts/%s) format('woff2');unicode-range:%s}",
+ $face['subset'],
+ $family,
+ $face['style'],
+ $face['weight'],
+ $name,
+ $face['range'],
+ );
+ }
+ }
+ if ([] === $rules) {
+ throw new \RuntimeException('Google Fonts hat keine passende Schriftdatei geliefert.');
+ }
+ file_put_contents($this->directory.'/fonts.css', implode("\n", $rules)."\n");
+
+ return ['files' => $files, 'bytes' => $bytes, 'families' => array_keys($wanted)];
+ }
+
+ /**
+ * Die Dateien, die für den ersten Eindruck vorab geholt werden sollen.
+ *
+ * Nur der lateinische Grundbereich und nur die Schnitte, die im Fließtext und in
+ * Überschriften stehen - ein Vorabholen, das alles holt, verzögert genau das, was es
+ * beschleunigen soll.
+ *
+ * @return list<string>
+ */
+ public function preload(array $theme): array
+ {
+ $preload = [];
+ foreach ($this->wanted($theme) as $family => $weights) {
+ foreach (array_slice($weights, 0, 2) as $weight) {
+ $name = $this->slug($family).'-'.$weight.'-latin.woff2';
+ if (is_file($this->directory.'/'.$name)) {
+ $preload[] = '/assets/fonts/'.$name;
+ }
+ }
+ }
+
+ return $preload;
+ }
+
+ /**
+ * Welche Familien und Schnitte das Theme von Google bezieht.
+ *
+ * @return array<string, list<int>>
+ */
+ private function wanted(array $theme): array
+ {
+ $wanted = [];
+ foreach ($theme['fonts'] ?? [] as $font) {
+ if ('google' !== ($font['source'] ?? '') || '' === ($font['family'] ?? '')) {
+ continue;
+ }
+ $weights = array_map(intval(...), $font['weights'] ?? [400]);
+ sort($weights);
+ $wanted[$font['family']] = array_values(array_unique([...($wanted[$font['family']] ?? []), ...$weights]));
+ sort($wanted[$font['family']]);
+ }
+
+ return $wanted;
+ }
+
+ private function stylesheet(string $family, array $weights): string
+ {
+ $url = sprintf(
+ 'https://fonts.googleapis.com/css2?family=%s:wght@%s&display=swap',
+ rawurlencode($family),
+ implode(';', $weights),
+ );
+
+ $css = $this->get($url);
+ if (!str_contains($css, '@font-face')) {
+ throw new \RuntimeException(sprintf('Google Fonts liefert für „%s“ keine Schrift. Schreibt sich die Familie genau so?', $family));
+ }
+
+ return $css;
+ }
+
+ private function download(string $url): string
+ {
+ if (!str_starts_with($url, 'https://fonts.gstatic.com/')) {
+ throw new \RuntimeException('Die Schriftdatei käme von einer fremden Adresse: '.$url);
+ }
+
+ $body = $this->get($url);
+ // Eine WOFF2-Datei beginnt mit "wOF2". Was anderes ist, wird nicht gespeichert.
+ if (!str_starts_with($body, 'wOF2')) {
+ throw new \RuntimeException('Die geladene Datei ist keine WOFF2-Schrift.');
+ }
+
+ return $body;
+ }
+
+ /**
+ * Liest die @font-face-Blöcke eines Google-Stylesheets.
+ *
+ * Der Zeichenbereich steht in einem Kommentar vor jedem Block („/* latin *\/“); danach wird
+ * ausgewählt, was eine deutschsprachige Website braucht.
+ *
+ * @return list<array{subset: string, weight: int, style: string, url: string, range: string}>
+ */
+ public function parse(string $css, string $family): array
+ {
+ $faces = [];
+ preg_match_all('#/\*\s*([a-z0-9-]+)\s*\*/\s*@font-face\s*\{(.+?)\}#s', $css, $matches, PREG_SET_ORDER);
+ foreach ($matches as [, $subset, $block]) {
+ if (!in_array($subset, self::SUBSETS, true)) {
+ continue;
+ }
+ if (1 !== preg_match('#src:\s*url\(([^)]+)\)#', $block, $src)) {
+ continue;
+ }
+ preg_match('#font-weight:\s*(\d+)#', $block, $weight);
+ preg_match('#font-style:\s*([a-z]+)#', $block, $style);
+ preg_match('#unicode-range:\s*([^;}]+)#', $block, $range);
+ $faces[] = [
+ 'subset' => $subset,
+ 'weight' => (int) ($weight[1] ?? 400),
+ 'style' => $style[1] ?? 'normal',
+ 'url' => trim($src[1], '\'" '),
+ 'range' => trim($range[1] ?? 'U+0000-00FF'),
+ 'family' => $family,
+ ];
+ }
+
+ return $faces;
+ }
+
+ /**
+ * Holt eine HTTPS-Adresse - erst über curl, sonst über den Dateizeiger.
+ *
+ * Dieselben zwei Wege wie im Installer, aus demselben Grund: auf einem Webhosting ist mal das
+ * eine da und mal das andere. Eine weitere Abhängigkeit dafür ins Projekt zu holen, würde
+ * jedes Update auf einem Hosting ohne Composer scheitern lassen.
+ */
+ private function get(string $url): string
+ {
+ if (!str_starts_with($url, 'https://')) {
+ throw new \RuntimeException('Geladen wird nur über HTTPS.');
+ }
+ if (function_exists('curl_init')) {
+ $curl = curl_init($url);
+ curl_setopt_array($curl, [
+ CURLOPT_RETURNTRANSFER => true,
+ CURLOPT_FOLLOWLOCATION => true,
+ CURLOPT_MAXREDIRS => 3,
+ CURLOPT_SSL_VERIFYPEER => true,
+ CURLOPT_SSL_VERIFYHOST => 2,
+ CURLOPT_CONNECTTIMEOUT => 15,
+ CURLOPT_TIMEOUT => 60,
+ CURLOPT_USERAGENT => self::AGENT,
+ ]);
+ $body = curl_exec($curl);
+ $status = curl_getinfo($curl, CURLINFO_RESPONSE_CODE);
+ $error = curl_error($curl);
+ curl_close($curl);
+ if (!is_string($body) || 200 !== $status) {
+ throw new \RuntimeException(sprintf('Google Fonts antwortet mit %d%s.', $status, '' === $error ? '' : ' ('.$error.')'));
+ }
+
+ return $body;
+ }
+ if (!filter_var(ini_get('allow_url_fopen'), FILTER_VALIDATE_BOOL)) {
+ throw new \RuntimeException('Dieser Server darf nicht nach außen verbinden (weder curl noch allow_url_fopen). Die Schriftdateien müssen dann von Hand nach public/assets/fonts/ gelegt werden.');
+ }
+ $context = stream_context_create([
+ 'http' => ['timeout' => 60, 'follow_location' => 1, 'max_redirects' => 3, 'header' => 'User-Agent: '.self::AGENT],
+ 'ssl' => ['verify_peer' => true, 'verify_peer_name' => true],
+ ]);
+ $body = @file_get_contents($url, false, $context);
+ if (!is_string($body)) {
+ throw new \RuntimeException('Google Fonts ist von diesem Server aus nicht erreichbar.');
+ }
+
+ return $body;
+ }
+
+ private function slug(string $family): string
+ {
+ return strtolower(preg_replace('/[^a-z0-9]+/i', '-', $family) ?? 'schrift');
+ }
+}
diff --git a/src/Content/PageRepository.php b/src/Content/PageRepository.php
index e73329b..ee7d438 100644
--- a/src/Content/PageRepository.php
+++ b/src/Content/PageRepository.php
@@ -368,7 +368,7 @@ final class PageRepository
public function findPublished(string $path, string $locale = 'de'): ?array
{
$page = $this->db->fetchAssociative(
- 'SELECT p.id, p.slug, p.path, p.type, p.locale, p.author, p.excerpt, p.published_at, p.robots, p.og_media_id, p.featured_media_id, p.header_area, p.footer_area, r.document, r.id AS revision_id, w.name AS website_name FROM page p JOIN revision r ON r.id = p.published_revision_id AND r.page_id = p.id JOIN website w ON w.id = p.website_id WHERE p.path = ? AND p.locale = ? AND p.website_id = ? AND p.deleted_at IS NULL',
+ 'SELECT p.id, p.slug, p.path, p.type, p.locale, p.author, p.excerpt, p.published_at, p.robots, p.seo_title, p.og_media_id, p.featured_media_id, p.header_area, p.footer_area, r.document, r.id AS revision_id, w.name AS website_name FROM page p JOIN revision r ON r.id = p.published_revision_id AND r.page_id = p.id JOIN website w ON w.id = p.website_id WHERE p.path = ? AND p.locale = ? AND p.website_id = ? AND p.deleted_at IS NULL',
[$path, $locale, 'default'],
);
if (false === $page) {
@@ -417,7 +417,7 @@ final class PageRepository
public function listForEditor(): array
{
- return $this->db->fetchAllAssociative('SELECT p.id, p.slug, p.path, p.parent_id, p.type, p.locale, p.version, p.published_revision_id, p.draft_revision_id, p.excerpt, p.author, p.published_at, p.featured_media_id, p.robots, p.og_media_id, p.publish_at, p.header_area, p.footer_area, r.document FROM page p LEFT JOIN revision r ON r.id = p.draft_revision_id AND r.page_id = p.id WHERE p.website_id = ? AND p.deleted_at IS NULL ORDER BY p.path', ['default']);
+ return $this->db->fetchAllAssociative('SELECT p.id, p.slug, p.path, p.parent_id, p.type, p.locale, p.version, p.published_revision_id, p.draft_revision_id, p.excerpt, p.author, p.published_at, p.featured_media_id, p.robots, p.seo_title, p.og_media_id, p.publish_at, p.header_area, p.footer_area, r.document FROM page p LEFT JOIN revision r ON r.id = p.draft_revision_id AND r.page_id = p.id WHERE p.website_id = ? AND p.deleted_at IS NULL ORDER BY p.path', ['default']);
}
public function findForEditor(string $id): ?array
diff --git a/src/Content/PostRepository.php b/src/Content/PostRepository.php
index 0567f14..0b3aa43 100644
--- a/src/Content/PostRepository.php
+++ b/src/Content/PostRepository.php
@@ -46,20 +46,27 @@ final class PostRepository
throw new InvalidPage(sprintf('Das gewählte %s gibt es nicht.', $label));
}
}
+ // Der Titel fuer die Suche. Leer heisst: der Titel der Seite gilt. 160 Zeichen sind die
+ // Grenze des Feldes; Google zeigt etwa 60 - der Hinweis dazu steht im Formular.
+ $seoTitle = trim((string) ($values['seoTitle'] ?? ''));
+ if (mb_strlen($seoTitle) > 160) {
+ throw new InvalidPage('Der Titel für Suchergebnisse darf höchstens 160 Zeichen lang sein.');
+ }
$robots = (string) ($values['robots'] ?? 'index');
if (!in_array($robots, ['index', 'noindex'], true)) {
throw new InvalidPage('Für die Indexierung sind nur „index“ und „noindex“ vorgesehen.');
}
- $this->db->transactional(function () use ($pageId, $excerpt, $author, $date, $mediaId, $ogMediaId, $robots, $categories, $tags, $expectedVersion): void {
+ $this->db->transactional(function () use ($pageId, $excerpt, $author, $date, $mediaId, $ogMediaId, $robots, $seoTitle, $categories, $tags, $expectedVersion): void {
$changed = $this->db->executeStatement(
- 'UPDATE page SET excerpt = ?, author = ?, featured_media_id = ?, published_at = ?, robots = ?, og_media_id = ?, version = version + 1 WHERE id = ? AND version = ?',
+ 'UPDATE page SET excerpt = ?, author = ?, featured_media_id = ?, published_at = ?, robots = ?, seo_title = ?, og_media_id = ?, version = version + 1 WHERE id = ? AND version = ?',
[
'' === $excerpt ? null : $excerpt,
'' === $author ? null : $author,
'' === $mediaId ? null : $mediaId,
'' === $date ? null : str_replace('T', ' ', 10 === strlen($date) ? $date.' 00:00' : $date).':00',
$robots,
+ '' === $seoTitle ? null : $seoTitle,
'' === $ogMediaId ? null : $ogMediaId,
$pageId,
$expectedVersion,
diff --git a/src/Content/StyleBundle.php b/src/Content/StyleBundle.php
new file mode 100644
index 0000000..bd522b6
--- /dev/null
+++ b/src/Content/StyleBundle.php
@@ -0,0 +1,126 @@
+<?php
+
+namespace App\Content;
+
+/**
+ * Die Stylesheets einer öffentlichen Seite als eine Datei.
+ *
+ * Getrennte Dateien sind beim Schreiben richtig – `site.css` das Grundgerüst, `design.css` die
+ * Gestaltungswerte, `enhancements.css` die Bewegung, `fonts/fonts.css` die Schriften. Beim
+ * Ausliefern sind sie vier Anfragen, die alle vier das Zeichnen der Seite aufhalten, und auf einer
+ * Mobilfunkverbindung ist jede davon eine eigene Wartezeit.
+ *
+ * Zusammengelegt wird deshalb einmal in eine Datei, deren Name die Prüfsumme des Inhalts trägt:
+ * ändert sich eine Quelle, ändert sich der Name, und kein Browser zeigt altes Aussehen. Entfernt
+ * werden dabei die Kommentare – sie erklären den Quelltext, nicht den Browser.
+ *
+ * Schlägt das Schreiben fehl (kein Schreibrecht im Ordner), bleibt es bei den Einzeldateien: eine
+ * Website ohne Bündel ist langsamer, eine Website ohne Stylesheet ist kaputt.
+ */
+final class StyleBundle
+{
+ /** Die Reihenfolge ist die Reihenfolge im Kopf der Seite - später gewinnt. */
+ private const SOURCES = ['fonts/fonts.css', 'site.css', 'design.css', 'enhancements.css'];
+
+ public function __construct(private string $assetDirectory)
+ {
+ }
+
+ /**
+ * Die Adresse des Bündels, oder null wenn es keines gibt.
+ *
+ * Erzeugt wird beim ersten Aufruf nach einer Änderung. Das kostet einen Aufruf lang ein paar
+ * Millisekunden und spart danach jedem Besucher drei Anfragen.
+ */
+ public function url(bool $withFonts = true): ?string
+ {
+ $sources = $this->sources($withFonts);
+ if ([] === $sources) {
+ return null;
+ }
+ $name = 'kant-'.substr(hash('xxh128', implode('|', array_map(
+ static fn (string $file): string => $file.':'.filemtime($file).':'.filesize($file),
+ $sources,
+ ))), 0, 16).'.css';
+ $path = $this->assetDirectory.'/build/'.$name;
+ if (!is_file($path) && !$this->write($path, $sources)) {
+ return null;
+ }
+
+ return '/assets/build/'.$name;
+ }
+
+ /** @return list<string> */
+ private function sources(bool $withFonts): array
+ {
+ $found = [];
+ foreach (self::SOURCES as $source) {
+ if ('fonts/fonts.css' === $source && !$withFonts) {
+ continue;
+ }
+ $path = $this->assetDirectory.'/'.$source;
+ if (is_file($path)) {
+ $found[] = $path;
+ }
+ }
+
+ // Ohne das Grundgerüst kein Bündel: dann stimmt etwas anderes nicht.
+ return in_array($this->assetDirectory.'/site.css', $found, true) ? $found : [];
+ }
+
+ /** @param list<string> $sources */
+ private function write(string $path, array $sources): bool
+ {
+ $directory = dirname($path);
+ if (!is_dir($directory) && !@mkdir($directory, 0775, true) && !is_dir($directory)) {
+ return false;
+ }
+ $css = '';
+ foreach ($sources as $source) {
+ $css .= $this->minify((string) file_get_contents($source))."\n";
+ }
+ // Erst daneben schreiben, dann umbenennen: ein zweiter Aufruf im selben Moment soll nie
+ // eine halb geschriebene Datei ausliefern.
+ $temporary = $path.'.'.bin2hex(random_bytes(4));
+ if (false === @file_put_contents($temporary, $css) || !@rename($temporary, $path)) {
+ @unlink($temporary);
+
+ return false;
+ }
+ $this->clean($directory, basename($path));
+
+ return true;
+ }
+
+ /**
+ * Kommentare raus, Einrückung raus - sonst nichts.
+ *
+ * Kein Umbau von Selektoren, kein Zusammenfassen von Regeln: ein Minifier, der die Bedeutung
+ * ändert, spart ein paar Zeichen und kostet einen Abend Fehlersuche. Leerzeichen innerhalb
+ * einer Zeile bleiben deshalb stehen – in `calc(100% - 20px)` und in `.a :hover` tragen sie
+ * Bedeutung.
+ */
+ private function minify(string $css): string
+ {
+ $withoutComments = preg_replace('#/\*(?!!).*?\*/#s', '', $css) ?? $css;
+ $lines = [];
+ foreach (preg_split('/\R/', $withoutComments) ?: [] as $line) {
+ $line = trim($line);
+ if ('' !== $line) {
+ $lines[] = $line;
+ }
+ }
+
+ return implode("\n", $lines);
+ }
+
+ /** Ältere Bündel wegräumen; sie werden von niemandem mehr angefragt. */
+ private function clean(string $directory, string $keep): void
+ {
+ foreach (glob($directory.'/kant-*.css') ?: [] as $old) {
+ if (basename($old) !== $keep && filemtime($old) < time() - 3600) {
+ @unlink($old);
+ }
+ }
+ }
+}
diff --git a/src/Content/StyleCompiler.php b/src/Content/StyleCompiler.php
index 223cc78..14cde37 100644
--- a/src/Content/StyleCompiler.php
+++ b/src/Content/StyleCompiler.php
@@ -101,6 +101,7 @@ final class StyleCompiler
private function compileBlock(string $id, array $style): string
{
$css = '';
+ $style = $this->scaleBackground($style);
foreach (['desktop', 'tablet', 'mobile'] as $device) {
$values = $style[$device] ?? null;
if (!is_array($values)) {
@@ -322,6 +323,39 @@ final class StyleCompiler
* Mobile takes the smallest that is at least 960 wide, tablet the one around 1600, desktop the
* largest. A picture that only has small variants simply gives what it has.
*/
+ /**
+ * Ein Hintergrundbild gilt auch dann in Gerätegrößen, wenn es nur einmal gesetzt wurde.
+ *
+ * Wer im Editor ein Hintergrundbild wählt, setzt es üblicherweise am Schreibtisch - also unter
+ * „Desktop“. Ohne eigene Regel für die kleineren Geräte erbt ein Telefon diese Regel und lädt
+ * die größte Variante: gemessen 189 KB statt 40 KB für ein Bild, das nie in dieser Auflösung
+ * zu sehen ist. CSS kennt kein srcset, aber die Regeln stehen ohnehin je Gerät da - also
+ * bekommt jedes Gerät dieselbe Bildwahl, die es bekäme, wenn jemand sie einzeln gesetzt hätte.
+ *
+ * Ein ausdrücklich gesetztes Bild wird nie ersetzt; ergänzt wird nur, wo nichts steht.
+ */
+ private function scaleBackground(array $style): array
+ {
+ $image = $style['desktop']['backgroundImage'] ?? null;
+ if (null === $image) {
+ return $style;
+ }
+ foreach (['tablet', 'mobile'] as $device) {
+ if (!isset($style[$device]['backgroundImage'])) {
+ $style[$device]['backgroundImage'] = $image;
+ // Verlauf und Überlagerung gehören zur selben Regel: ohne sie stünde auf dem
+ // Telefon plötzlich ein unabgedunkeltes Bild hinter hellem Text.
+ foreach (['gradientFrom', 'gradientTo', 'gradientAngle', 'overlayColor', 'overlayOpacity', 'backgroundSize', 'backgroundPosition', 'backgroundRepeat', 'backgroundAttachment'] as $begleiter) {
+ if (isset($style['desktop'][$begleiter]) && !isset($style[$device][$begleiter])) {
+ $style[$device][$begleiter] = $style['desktop'][$begleiter];
+ }
+ }
+ }
+ }
+
+ return $style;
+ }
+
private function variantFor(array $variants, string $device): array
{
$wanted = ['mobile' => 960, 'tablet' => 1600, 'desktop' => 4000][$device] ?? 4000;
diff --git a/src/Controller/EditorController.php b/src/Controller/EditorController.php
index f6ddc61..91dc870 100644
--- a/src/Controller/EditorController.php
+++ b/src/Controller/EditorController.php
@@ -145,6 +145,7 @@ final class EditorController extends AbstractController
'publishedAt' => $request->request->getString('publishedAt'),
'featuredMediaId' => $request->request->getString('featuredMediaId'),
'ogMediaId' => $request->request->getString('ogMediaId'),
+ 'seoTitle' => $request->request->getString('seoTitle'),
'robots' => $request->request->getString('robots', 'index'),
],
$terms($request->request->getString('categories')),
diff --git a/src/Controller/PageController.php b/src/Controller/PageController.php
index d0eac41..e41a57e 100644
--- a/src/Controller/PageController.php
+++ b/src/Controller/PageController.php
@@ -4,6 +4,7 @@ namespace App\Controller;
use App\Content\Consent;
use App\Content\CustomCode;
+use App\Content\FontLibrary;
use App\Content\FormRepository;
use App\Content\MediaLibrary;
use App\Content\MenuRepository;
@@ -12,6 +13,7 @@ use App\Content\PartialRepository;
use App\Content\PostRepository;
use App\Content\RedirectRepository;
use App\Content\SiteSettings;
+use App\Content\StyleBundle;
use App\Content\StyleCompiler;
use App\Content\Theme;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
@@ -21,7 +23,7 @@ use Symfony\Component\Routing\Attribute\Route;
final class PageController extends AbstractController
{
- public function __construct(private PageRepository $pages, private MenuRepository $menus, private PostRepository $posts, private FormRepository $forms, private RedirectRepository $redirects, private SiteSettings $settings, private PartialRepository $partials, private CustomCode $code, private Consent $consent, private Theme $theme, private StyleCompiler $styles, private MediaLibrary $media, private string $secret, private string $siteOrigin)
+ public function __construct(private PageRepository $pages, private MenuRepository $menus, private PostRepository $posts, private FormRepository $forms, private RedirectRepository $redirects, private SiteSettings $settings, private PartialRepository $partials, private CustomCode $code, private Consent $consent, private Theme $theme, private StyleCompiler $styles, private MediaLibrary $media, private FontLibrary $fonts, private StyleBundle $bundle, private string $secret, private string $siteOrigin)
{
}
@@ -42,6 +44,7 @@ final class PageController extends AbstractController
$page = $this->pages->findPublished($path);
$styles = '';
$googleFonts = null;
+ $localFonts = [];
// The page decides which header and footer it gets - including none.
$areas = $this->areas($page);
if (null !== $page) {
@@ -52,7 +55,13 @@ final class PageController extends AbstractController
foreach ([...array_values($areas), ...array_values($sections)] as $extra) {
$styles .= $this->styles->compileDocument($extra).$this->code->compileDocument($extra);
}
- $googleFonts = $this->theme->googleFontsUrl($theme);
+ // Liegen die Schriften auf dem eigenen Server, wird nichts von Google geholt - weder
+ // die Datei noch die IP-Adresse des Besuchers.
+ if ($this->fonts->hasLocal($theme)) {
+ $localFonts = $this->fonts->preload($theme);
+ } else {
+ $googleFonts = $this->theme->googleFontsUrl($theme);
+ }
}
if (null === $page) {
// An address that moved or was deliberately removed answers before the 404 does.
@@ -87,9 +96,14 @@ final class PageController extends AbstractController
'areas' => $areas,
'sections' => $sections,
// Rendered before the page content, so the header decides first.
- 'eagerImage' => $this->firstImage($areas['header'] ?? [], $page['document']),
+ // Das grosse Bild ueber der Falz - es soll zuerst geladen werden. Gesucht wird nur
+ // im ersten Abschnitt des Inhalts: ein Bild weiter unten waere die falsche
+ // Eile, und das Logo im Kopfbereich ist klein und laedt ohnehin sofort.
+ 'eagerImage' => $this->firstImage(['blocks' => array_slice($page['document']['blocks'] ?? [], 0, 1)]),
'pageStyles' => $styles,
'googleFonts' => $googleFonts,
+ 'localFonts' => $localFonts,
+ 'styleBundle' => $this->bundle->url([] !== $localFonts),
]);
}
diff --git a/src/Controller/ThemeController.php b/src/Controller/ThemeController.php
index 7540f15..699677b 100644
--- a/src/Controller/ThemeController.php
+++ b/src/Controller/ThemeController.php
@@ -2,6 +2,7 @@
namespace App\Controller;
+use App\Content\FontLibrary;
use App\Content\Theme;
use App\Domain\InvalidPage;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
@@ -11,20 +12,59 @@ use Symfony\Component\Routing\Attribute\Route;
final class ThemeController extends AbstractController
{
- public function __construct(private Theme $theme)
+ public function __construct(private Theme $theme, private FontLibrary $fonts)
{
}
#[Route('/admin/theme', name: 'admin_theme', methods: ['GET'])]
public function index(): Response
{
+ $theme = $this->theme->load();
+
return $this->render('admin/theme.html.twig', [
- 'theme' => $this->theme->load(),
+ 'theme' => $theme,
'fallbacks' => Theme::FALLBACKS,
'weights' => Theme::WEIGHTS,
+ 'fontsLocal' => $this->fonts->hasLocal($theme),
+ 'fontsMissing' => $this->fonts->missing($theme),
]);
}
+ /**
+ * Holt die gewaehlten Google-Schriften auf den eigenen Server.
+ *
+ * Auf Zuruf, nicht bei einem Seitenaufruf: das dauert Sekunden und braucht eine Verbindung
+ * nach aussen, die ein Besucher nie abwarten soll.
+ */
+ #[Route('/admin/theme/fonts', name: 'admin_theme_fonts', methods: ['POST'])]
+ public function fonts(Request $request): Response
+ {
+ $this->denyAccessUnlessGranted('ROLE_EDITOR');
+ if (!$this->isCsrfTokenValid('theme', $request->request->getString('_csrf_token'))) {
+ $this->addFlash('error', 'Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
+
+ return $this->redirectToRoute('admin_theme');
+ }
+ try {
+ $result = $this->fonts->fetch($this->theme->load());
+ $this->addFlash('success', sprintf(
+ '%d Schriftdatei(en) geladen, %s insgesamt: %s. Die Website lädt jetzt nichts mehr von Google.',
+ $result['files'],
+ $this->bytes($result['bytes']),
+ implode(', ', $result['families']),
+ ));
+ } catch (\RuntimeException $error) {
+ $this->addFlash('error', $error->getMessage());
+ }
+
+ return $this->redirectToRoute('admin_theme');
+ }
+
+ private function bytes(int $bytes): string
+ {
+ return $bytes < 1024 * 1024 ? round($bytes / 1024).' KB' : round($bytes / 1024 / 1024, 1).' MB';
+ }
+
#[Route('/admin/theme/save', name: 'admin_theme_save', methods: ['POST'])]
public function save(Request $request): Response
{
diff --git a/templates/admin/base.html.twig b/templates/admin/base.html.twig
index 76ccc99..64fdf24 100644
--- a/templates/admin/base.html.twig
+++ b/templates/admin/base.html.twig
@@ -6,7 +6,7 @@
<meta name="robots" content="noindex, nofollow">
<title>{% block title %}Verwaltung{% endblock %} · KantSites
{% include 'favicon.html.twig' %}
-
+
{% block styles %}{% endblock %}
{% block scripts %}{% endblock %}
diff --git a/templates/admin/editor.html.twig b/templates/admin/editor.html.twig
index 6d84eaf..1587e72 100644
--- a/templates/admin/editor.html.twig
+++ b/templates/admin/editor.html.twig
@@ -3,8 +3,8 @@
{% set subject = area ? area.document : page.document %}
{% block title %}{{ subject.title }} bearbeiten{% endblock %}
{% block body_class %}editor-body{% endblock %}
-{% block styles %}{% endblock %}
-{% block scripts %}{% endblock %}
+{% block styles %}{% endblock %}
+{% block scripts %}{% endblock %}
{% block body %}
{# The API base decides what is edited. An area is shared, so it has no draft and no
publication: saving is live, and the publish button is left out. #}
diff --git a/templates/admin/media.html.twig b/templates/admin/media.html.twig
index 99ceeef..4c9a90e 100644
--- a/templates/admin/media.html.twig
+++ b/templates/admin/media.html.twig
@@ -1,7 +1,7 @@
{% extends 'admin/shell.html.twig' %}
{% set nav = 'media' %}
{% block title %}Mediathek{% endblock %}
-{% block scripts %}{% endblock %}
+{% block scripts %}{% endblock %}
{% block heading %}Mediathek{% endblock %}
{% block lead %}Alle Bilder, neueste zuerst. Beim Hochladen wird jedes Bild in WebP umgewandelt und in mehreren Breiten abgelegt; die Seite liefert dann die passende aus.{% endblock %}
{% block content %}
diff --git a/templates/admin/pages.html.twig b/templates/admin/pages.html.twig
index 0e90d2c..da19d5b 100644
--- a/templates/admin/pages.html.twig
+++ b/templates/admin/pages.html.twig
@@ -88,6 +88,11 @@
+
+
+
+
Leer lassen, wenn der Titel der Seite auch in der Suche stehen soll. Google zeigt etwa 60 Zeichen und schneidet danach ab; was dahinter steht, liest niemand.