Merge fix/closed-day-icon-and-banner: Schloss-Symbol + durchgehendes Geschlossen-Banner

fix: Schloss-Symbol statt Text + durchgehendes Geschlossen-Banner
Ersetzt den "Tag schließen"-Textlink durch ein Schloss-Symbol (🔓/🔒) und lässt den "Geschlossen"-Hinweis eines geschlossenen Tages über alle Essenszeiten-Zeilen durchlaufen (per rowSpan), statt ihn in jeder Zeile einzeln zu wiederholen – sowohl im Wochenplan als auch auf der öffentlichen Speisekarte.
2026-07-20 12:49:46 +02:00 · 2026-07-20 12:49:04 +02:00 · 2026-07-20 12:35:31 +02:00 · 2026-07-20 12:35:00 +02:00 · 2026-07-20 11:23:30 +02:00 · 2026-07-20 11:22:49 +02:00
141 changed files with 10211 additions and 2415 deletions
@@ -5,7 +5,7 @@ node_modules
 .env*
 !.env.example
 ZUGANGSDATEN.md
-supabase/local
+data/branding
 Dockerfile
 docker-compose.yml
 README.md
@@ -1,18 +1,62 @@
 # Vorlage für .env.local (Entwicklung) bzw. die Umgebungsvariablen
 # beim Hoster (Live-Betrieb). Echte Werte niemals committen!

-# Supabase-Projekt-URL (Dashboard -> Project Settings -> API)
-NEXT_PUBLIC_SUPABASE_URL=https://<projekt-ref>.supabase.co
+# Nur für Docker Compose relevant: Passwort für den mitgelieferten
+# PostgreSQL-Container (Dienst "db" in docker-compose.yml). Daraus baut
+# docker-compose.yml die DATABASE_URL für die App-Container selbst
+# zusammen – die Zeile unten wird beim Betrieb per Docker Compose
+# NICHT verwendet, nur bei manuellem "npm run dev"/"npm run start"
+# gegen eine selbst betriebene PostgreSQL-Instanz.
+#
+# Nur Buchstaben/Zahlen verwenden (z. B. mit "openssl rand -hex 24"
+# erzeugen) – Zeichen wie #, $, Leerzeichen oder Anführungszeichen
+# werden von Docker Compose beim Einlesen von .env-Dateien speziell
+# behandelt (# beginnt z. B. einen Kommentar) und können das Passwort
+# unbemerkt verstümmeln.
+#
+# WICHTIG: PostgreSQL setzt dieses Passwort nur EINMALIG beim allerersten
+# Start auf einem leeren Datenverzeichnis. Wird der Wert hier später
+# geändert (oder "docker compose up" auch nur einmal ohne
+# "--env-file .env.local" ausgeführt, bevor er gesetzt war), bleibt im
+# bereits angelegten Docker-Volume das alte Passwort stehen – die App
+# bekommt dann "password authentication failed for user postgres". Fix:
+# "docker compose down && docker volume rm canteen-menu_pgdata", dann
+# neu starten (nur unbedenklich, solange noch keine echten Daten drin
+# sind – siehe DEPLOYMENT.md).
+LOCAL_PG_PASSWORD=<beliebiges-sicheres-passwort>

-# Öffentlicher anon-Key (darf im Browser landen, RLS schützt die Daten)
-NEXT_PUBLIC_SUPABASE_ANON_KEY=<anon-key>
-
-# Service-Role-Key (GEHEIM! Nur serverseitig, für die Benutzerverwaltung)
-SUPABASE_SERVICE_ROLE_KEY=<service-role-key>
+# Verbindung zur PostgreSQL-Datenbank (nur für den Betrieb OHNE Docker
+# Compose relevant, s. o.).
+DATABASE_URL=postgres://postgres:<passwort>@localhost:5432/canteen_menu

 # Öffentliche URL, unter der die App erreichbar ist (Schema + Domain).
 # Wird für den CSRF-Origin-Check hinter Reverse-Proxies genutzt und ist
-# zugleich die Passkey-Domain: nach einer Änderung einmalig
-#   SUPABASE_ACCESS_TOKEN=<token> node scripts/configure-passkeys.mjs
-# ausführen, damit Passkeys auf der neuen Domain funktionieren.
+# zugleich die Passkey-Domain (RP-ID/Origin werden direkt daraus
+# abgeleitet, kein separater Konfigurationsschritt nötig).
 APP_URL=http://localhost:3000
+
+# Titel im Browser-Tab und Überschrift, solange kein Logo hochgeladen ist.
+SITE_TITLE=Canteen Menu
+
+# Optional: E-Mail-Adresse für den automatisch angelegten Admin-Erstnutzer
+# (nur relevant, solange die users-Tabelle noch leer ist). Ohne Angabe
+# wird admin@<Hostname aus APP_URL> verwendet.
+ADMIN_EMAIL=
+
+# Optional: DeepL-API-Key für automatische Übersetzung von Gerichten nach
+# Englisch/Polnisch (kostenloser Free-Tier unter deepl.com/de/pro-api,
+# Free-Keys enden auf ":fx"). Ohne Key bleibt "Automatisch übersetzen"
+# inaktiv; Englisch/Polnisch lassen sich weiterhin manuell eintragen.
+DEEPL_API_KEY=
+
+# Optional: SSO-Login per OpenID Connect (z. B. gegen ein selbst
+# gehostetes Authentik). Ohne diese drei Werte bleibt der SSO-Button auf
+# der Anmeldeseite ausgeblendet, Passwort/Passkey funktionieren
+# unverändert. SSO-Login funktioniert NUR für bereits unter "Benutzer"
+# angelegte E-Mail-Adressen – es werden keine neuen Konten angelegt und
+# die Rolle (Admin/Kantinenmitarbeiter) bleibt ausschließlich dort
+# steuerbar. Beim Identity Provider als Redirect-URI eintragen:
+# <APP_URL>/api/auth/oidc/callback
+OIDC_ISSUER=
+OIDC_CLIENT_ID=
+OIDC_CLIENT_SECRET=
@@ -0,0 +1,444 @@
+# Changelog
+
+Alle nennenswerten Änderungen an diesem Projekt werden hier dokumentiert.
+Format angelehnt an [Keep a Changelog](https://keepachangelog.com/de/1.1.0/),
+Versionierung nach [Semantic Versioning](https://semver.org/lang/de/).
+
+## [1.12.1] – 2026-07-20
+
+### Geändert
+- Bedienung geschlossener Tage im Wochenplan überarbeitet: Statt eines
+  Text-Links am Datum markiert jetzt ein Schloss-Symbol (🔓 zum
+  Schließen, 🔒 zeigt „geschlossen" an und öffnet per Klick wieder) den
+  Tag. Ein geschlossener Tag zeigt sowohl im Wochenplan als auch auf
+  der öffentlichen Speisekarte (Desktop-Tabelle) einen einzigen, über
+  alle Essenszeiten-Zeilen durchgehenden „Geschlossen"-Hinweis statt
+  einer Wiederholung in jeder einzelnen Zeile.
+
+## [1.12.0] – 2026-07-20
+
+### Hinzugefügt
+- Einzelne Tage als geschlossen markierbar (z. B. Feiertage,
+  Betriebsausflug) – im Wochenplan lässt sich pro Tag über „Tag
+  schließen" ein optionaler, mehrsprachiger Grund hinterlegen (inkl.
+  automatischer Übersetzung per DeepL, sofern konfiguriert). Ein
+  geschlossener Tag:
+  - blendet in der Gerichte-Verwaltung des Wochenplans „Mahlzeit
+    hinzufügen" für diesen Tag aus (bestehende Einträge lassen sich
+    weiterhin entfernen), lässt sich per „Wieder öffnen" jederzeit
+    rückgängig machen.
+  - zeigt auf der öffentlichen Speisekarte (Desktop-Tabelle und
+    mobile Ansicht) einen „Geschlossen"-Hinweis mit Grund statt der
+    Essenszeiten-Spalten/-Karte für diesen Tag.
+  - erscheint im RSS-Feed als eigener Eintrag mit Schließungsgrund
+    statt eines leeren oder fehlenden Tages.
+  - Neue Tabellen `closed_days`/`closed_day_translations` (Migration
+    `0007_closed_days.sql`).
+
+## [1.11.1] – 2026-07-20
+
+### Behoben
+- Wurde Deutsch im Sprachen-Admin deaktiviert (z. B. um die App auf nur
+  Englisch zu reduzieren), blieb die gesamte App trotzdem auf Deutsch
+  stehen, sowohl im öffentlichen als auch im internen Bereich: `getLocale()`
+  fiel bei fehlendem/ungültigem Sprach-Cookie bisher immer fest auf
+  Deutsch zurück, unabhängig davon, ob Deutsch überhaupt noch aktiv war.
+  Da der Sprachumschalter sich bei nur einer aktiven Sprache zusätzlich
+  automatisch ausblendet, gab es keine Möglichkeit, das über die
+  Oberfläche zu korrigieren. Der Fallback nutzt jetzt Deutsch nur noch,
+  wenn es tatsächlich aktiv ist – sonst die erste aktive Sprache.
+
+## [1.11.0] – 2026-07-20
+
+### Hinzugefügt
+- Speiseplan-Inhalte variabel gemacht (Teil 2 des "mehrsprachig
+  variabel"-Umbaus): Gerichtnamen, Essenszeiten-Bezeichnungen sowie
+  Allergen-/Zusatzstoff-Namen sind jetzt genauso dynamisch mehrsprachig
+  wie die Bedienoberfläche aus Version 1.10.0, statt auf feste
+  Englisch-/Polnisch-Spalten begrenzt zu sein:
+  - In den Verwaltungsseiten (Gerichte, Essenszeiten, Allergene &
+    Zusatzstoffe) erscheint jetzt automatisch ein Eingabefeld je aktiv
+    geschalteter Sprache – wird im Sprachen-Admin eine neue Sprache
+    angelegt, taucht dort sofort ein passendes Feld auf, ohne
+    Codeänderung.
+  - Der "Automatisch übersetzen"-Button (DeepL) übersetzt künftig in
+    alle aktiven, von DeepL unterstützten Sprachen statt fix nur
+    Englisch/Polnisch.
+  - CSV-Export/-Import für Gerichte, Allergene und Zusatzstoffe hat
+    jetzt eine Spalte je aktiver Sprache (`name_en`, `name_fr`, …)
+    statt der bisher fest verdrahteten `name_en`/`name_pl`-Spalten.
+  - Reduziert der Admin das Sprachenfeature im Sprachen-Bereich auf nur
+    Deutsch, verschwinden diese Zusatzfelder ebenfalls automatisch aus
+    allen drei Verwaltungsseiten.
+
+### Geändert
+- Neue Migration `0006_content_translations.sql` ersetzt die festen
+  Spalten `name_en`/`name_pl` (Gerichte, Allergene, Zusatzstoffe) bzw.
+  `label_en`/`label_pl` (Essenszeiten) durch je eine
+  Übersetzungstabelle (`dish_translations`, `section_translations`,
+  `allergen_translations`, `additive_translations`); bestehende
+  Übersetzungen werden dabei automatisch übernommen.
+  **Vor dem Einspielen auf einem Produktivsystem unbedingt ein Backup
+  der Datenbank anlegen** – die alten Spalten werden nach der
+  Übernahme entfernt.
+
+## [1.10.0] – 2026-07-20
+
+### Hinzugefügt
+- Dynamisches Sprachpaket-System für die Bedienoberfläche (Teil 1 des
+  "mehrsprachig variabel"-Umbaus, Speiseplan-Inhalte folgen in einer
+  späteren Version). Sprachen sind jetzt zur Laufzeit über eine neue
+  Admin-Seite „Sprachen" verwaltbar statt fest im Code zu stehen:
+  - Vorlage der aktuellen deutschen Texte herunterladen, übersetzt
+    wieder hochladen – neue Übersetzungen werden sofort aktiv, ohne
+    Deployment.
+  - Fehlende Begriffe fallen automatisch auf Deutsch zurück statt leer
+    zu bleiben; die Admin-Seite zeigt pro Sprache Vollständigkeit in %
+    sowie „N neue Begriffe seit letztem Import", falls eine neue
+    App-Version zusätzliche Texte eingeführt hat.
+  - Sprachen lassen sich einzeln deaktivieren, bis auf eine einzige
+    reduzierbar (der Sprachumschalter blendet sich dann automatisch
+    aus) – mindestens eine muss aktiv bleiben.
+  - Neue Sprachen lassen sich direkt anlegen (Code + Anzeigename),
+    Deutsch bleibt als einzige garantiert vollständige Basis-Sprache
+    unlöschbar.
+  - Import validiert hochgeladene Übersetzungen gegen die aktuelle
+    Vorlage: Platzhalter wie `{message}` müssen erhalten bleiben,
+    unbekannte Schlüssel werden ignoriert statt Fehler zu werfen.
+  - Neue Tabellen `languages`/`ui_translations` (Migration `0004`),
+    bestehende Englisch-/Polnisch-Texte automatisch übernommen
+    (Migration `0005`) – keine manuelle Nacharbeit nötig.
+
+## [1.9.5] – 2026-07-20
+
+### Hinzugefügt
+- Interner Bereich (Wochenplan, Essenszeiten, Gerichte, Allergene &
+  Zusatzstoffe, Vorschläge, Benutzer, Design, Mein Konto) für
+  Mobilgeräte nutzbar gemacht. `AppHeader.tsx` bekommt unterhalb der
+  `sm`-Breakpoint-Grenze ein Hamburger-Menü mit denselben Links
+  gestapelt statt der bisherigen, bei schmalen Bildschirmen unübersichtlich
+  umbrechenden einzeiligen Navigation. Der Wochenplan (`WeekEditor.tsx`)
+  zeigt auf Mobilgeräten eine Tag-für-Tag-Ansicht mit Tab-Leiste
+  (Mo–Fr) statt der für 375px viel zu schmalen 6-spaltigen Tabelle –
+  Gericht hinzufügen/löschen funktioniert unverändert, da beide
+  Ansichten denselben Bearbeitungs-Zustand teilen. In DishManager,
+  CodeListManager, UserManager, SectionManager und PasskeyManager
+  brechen Kopf- und Listenzeilen jetzt bei Bedarf um, statt Buttons
+  abzuschneiden.
+
+## [1.9.0] – 2026-07-20
+
+### Hinzugefügt
+- SSO-Login per OpenID Connect (z. B. gegen ein selbst gehostetes
+  Authentik), zusätzlich zu Passwort und Passkey. Konfiguration über
+  drei optionale Env-Vars (`OIDC_ISSUER`, `OIDC_CLIENT_ID`,
+  `OIDC_CLIENT_SECRET`) – ohne sie bleibt der SSO-Button auf der
+  Anmeldeseite ausgeblendet. Authorization-Code-Flow mit PKCE, ID-Token-
+  Signaturprüfung gegen das JWKS des Providers (neue Abhängigkeit
+  `jose`), State/Nonce serverseitig kurzlebig und einmalig verwendbar
+  (neue Tabelle `oidc_states`, Migration `0003_oidc_state.sql`).
+  SSO-Login funktioniert ausschließlich für bereits unter „Benutzer“
+  angelegte E-Mail-Adressen – es werden nie neue Konten angelegt, und
+  die Rolle (Admin/Kantinenmitarbeiter) bleibt ausschließlich über die
+  bestehende Benutzerverwaltung steuerbar, nie aus SSO-Claims
+  übernommen. In DEPLOYMENT.md unter „SSO/OpenID Connect“ dokumentiert.
+
+## [1.8.1] – 2026-07-20
+
+### Hinzugefügt
+- `update.sh`: Update-Skript für Linux-Deployments – stoppt den Docker-
+  Stack, sichert lokale Änderungen an `docker-compose.yml` per
+  `git stash` (falls vorhanden), führt `git pull` aus, spielt die
+  Änderungen zurück und startet den Stack neu im Build-Modus. Bricht
+  bei einem `git pull`- oder Stash-Konflikt kontrolliert ab, statt mit
+  einem halb aktualisierten Stand weiterzumachen. In DEPLOYMENT.md unter
+  „Updates einspielen“ dokumentiert.
+
+## [1.8.0] – 2026-07-19
+
+### Hinzugefügt
+- Umschaltbarer Hinweismodus für Allergene/Zusatzstoffe: Auf der Seite
+  „Allergene & Zusatzstoffe“ kann zwischen der bisherigen detaillierten
+  Auswahl je Gericht und einem einfachen, in Deutsch/Englisch/Polnisch
+  editierbaren Hinweistext (z. B. „Bei Fragen zu Allergenen und
+  Zusatzstoffen wenden Sie sich bitte an das Kantinen-Team.“)
+  umgeschaltet werden. Im Hinweismodus entfällt auf der öffentlichen
+  Speisekarte die Legende und die Kürzel an den Gerichten, und in der
+  Gerichte-Verwaltung wird die Allergen-/Zusatzstoff-Auswahl beim
+  Bearbeiten ausgeblendet (bereits zugeordnete Daten bleiben in der
+  Datenbank erhalten). Umschalten und Hinweistext bearbeiten dürfen
+  sowohl Kantinenpersonal als auch Admins.
+
+## [1.7.0] – 2026-07-19
+
+### Hinzugefügt
+- CSV-Import/-Export für Gerichte, Allergene und Zusatzstoffe (Buttons
+  „Exportieren“/„Importieren“ auf den jeweiligen Verwaltungsseiten).
+  Export lädt die aktuelle Liste als CSV herunter (Gerichte:
+  `name,name_en,name_pl,price,allergens,additives`, Allergene/
+  Zusatzstoffe: `code,name,name_en,name_pl`; Kürzel bei Gerichten
+  Semikolon-getrennt in einer Zelle, z. B. `A;G`). Import liest dieselbe
+  Spaltenstruktur (Reihenfolge egal, Groß-/Kleinschreibung der
+  Kopfzeile wird ignoriert) und aktualisiert bestehende Einträge
+  (Abgleich über Kürzel bei Allergenen/Zusatzstoffen, über den exakten
+  Namen bei Gerichten) bzw. legt neue an. Zeilen mit fehlenden
+  Pflichtfeldern, ungültigem Preis oder mehrdeutigem Gerichtsnamen
+  (mehrere Gerichte mit demselben Namen) werden übersprungen und mit
+  Grund in der Erfolgsmeldung aufgelistet, statt den ganzen Import
+  abzubrechen.
+
+### Behoben
+- RSS-Feed (`/feed.xml`): Mehrere Feed-Reader (u. a. Outlook,
+  Thunderbird) behandeln `<description>` als kurze Vorschau und kürzen
+  sie eigenmächtig – dadurch war bei Tagen mit mehreren Essenszeiten
+  oft nur die erste sichtbar, obwohl der Server bereits alle
+  Essenszeiten des Tages in der Beschreibung lieferte. Zusätzlich zu
+  `<description>` wird jetzt auch `<content:encoded>` (RSS-Content-
+  Modul) mit demselben vollständigen Inhalt ausgeliefert – von den
+  meisten Readern als vollständiger Artikeltext erkannt und ungekürzt
+  angezeigt.
+
+## [1.6.3] – 2026-07-18
+
+### Behoben
+- `docker-compose.yml`: Der `app`-Dienst setzte `BRANDING_DIR` nicht, sodass
+  `lib/branding.ts` beim Hochladen von Logo/Favicon auf den Fallback-Pfad
+  `${cwd}/data/branding` (= `/app/data/branding`) statt auf das im
+  Dockerfile vorbereitete, gemountete Verzeichnis `/data/branding` auswich.
+  `/app` gehört im Container `root`, der App-Prozess läuft aber als
+  nicht-root-Nutzer `nextjs` – das Anlegen des Fallback-Verzeichnisses
+  scheiterte mit `EACCES`, der Upload endete mit „Upload fehlgeschlagen:
+  500". Jetzt wird `BRANDING_DIR=/data/branding` explizit gesetzt, passend
+  zum Volume-Mount und zum in `Dockerfile` per `chown` freigegebenen
+  Verzeichnis.
+
+## [1.6.2] – 2026-07-18
+
+### Behoben
+- `scripts/bootstrap-admin.mjs`: Konnte `ZUGANGSDATEN.md` nicht
+  geschrieben werden (z. B. `EACCES`, weil die per Bind-Mount
+  eingebundene Host-Datei root gehört und der App-Container als
+  nicht-root läuft), brach das Skript ab, nachdem der Admin-Benutzer
+  bereits in der Datenbank angelegt war – das generierte Passwort war
+  dann nirgends mehr zu finden. Schreibt jetzt bei einem Fehler
+  stattdessen E-Mail/Passwort ins Log und beendet sich weiterhin
+  erfolgreich.
+- DEPLOYMENT.md: Schritt 2 fehlte `chmod 666 ZUGANGSDATEN.md` (der
+  eigentliche Auslöser des Bugs oben). Neue Fehlerbehebung-Einträge für
+  `ECONNREFUSED` beim Start (harmlose Start-Reihenfolge, löst sich
+  durch den automatischen Neustart von selbst) und für diesen
+  `EACCES`-Fall inkl. Recovery-Anleitung für einen bereits verwaisten
+  Admin-Account.
+
+## [1.6.1] – 2026-07-18
+
+### Geändert
+- PostgreSQL-Container ist nicht mehr über einen Host-Port erreichbar
+  (`docker-compose.yml`: `ports: 5433:5432` beim `db`-Dienst entfernt).
+  App und Dev-Server erreichen die Datenbank weiterhin über das von
+  Docker Compose automatisch angelegte interne Netzwerk (Hostname
+  `db`) – reduziert die Angriffsfläche, ohne den Betrieb zu ändern.
+  Debugging/Backup weiterhin über `docker compose exec db psql`/
+  `pg_dump` möglich.
+
+### Behoben
+- DEPLOYMENT.md: Fehlerbehebung-Abschnitt für
+  `password authentication failed for user "postgres"` ergänzt (tritt
+  auf, wenn `docker compose up` vor dem Setzen von `LOCAL_PG_PASSWORD`
+  läuft oder ohne `--env-file .env.local` – PostgreSQL übernimmt das
+  Passwort nur beim allerersten Start auf leerem Datenverzeichnis).
+  `.env.example` warnt jetzt vor Sonderzeichen in `LOCAL_PG_PASSWORD`,
+  die beim `.env`-Parsing zu stillen Fehlern führen können.
+
+## [1.6.0] – 2026-07-18
+
+### Hinzugefügt
+- RSS-Feed des Speiseplans (`/feed.xml`, ein Eintrag pro Tag mit den
+  Gerichten je Essenszeit für die aktuelle und die nächste Woche) zum
+  Abonnieren in einem Feedreader. Autodiscovery-Link im Seiten-`<head>`
+  sowie sichtbares RSS-Icon im Kopfbereich der öffentlichen
+  Speisekarte.
+- Kantinen-Bereich: „Vorschläge“-Navigationspunkt zeigt jetzt die
+  Anzahl offener Rezeptvorschläge als Zahl im roten Kreis.
+- Neues [DEPLOYMENT.md](DEPLOYMENT.md): Schritt-für-Schritt-Anleitung
+  für die Inbetriebnahme auf einem neuen Server (Docker Compose,
+  Konfiguration, Reverse-Proxy/HTTPS, Updates, Backup).
+
+### Geändert
+- Letzte Erwähnungen von Supabase in aktiven Doku-Texten und
+  Code-Kommentaren entfernt/umformuliert (README, Migrationsschema,
+  Passkey-Konfiguration, Branding-Ablage) – die App läuft seit v1.5
+  vollständig ohne Supabase, das sollte sich jetzt auch durchgängig in
+  der Dokumentation widerspiegeln. Historische CHANGELOG-Einträge
+  bleiben unverändert.
+- `.env.example`: `LOCAL_PG_PASSWORD` (von `docker-compose.yml`
+  verwendet, um die Datenbank-Verbindung der App-Container
+  zusammenzubauen) war bisher nirgends dokumentiert – beim Schreiben
+  der Deployment-Anleitung aufgefallen und ergänzt.
+
+## [1.5.0] – 2026-07-18
+
+### Hinzugefügt
+- Wochenplan: „Mahlzeit hinzufügen" bietet jetzt ein Suchfeld mit
+  gefilterter Trefferliste statt einer langen Dropdown-Liste zum
+  Durchscrollen.
+- `db/seed-demo.sql` (`npm run db:seed-demo`): spielt für lokale
+  Entwicklung/Demos den ursprünglichen Beispieldatensatz ein
+  (Essenszeiten, Allergene, Zusatzstoffe, Testgerichte, zwei
+  Beispielwochen) – kein Teil der automatischen Migrationen, frische
+  Deployments starten weiterhin leer.
+
+### Geändert
+- **Supabase vollständig entfernt** – die App läuft jetzt komplett
+  selbst gehostet, einzige externe Abhängigkeit bleibt optional DeepL.
+  - Datenbank: selbst gehostetes PostgreSQL statt Supabase-Cloud-Postgres.
+    Schema in `db/migrations/*.sql`, wird beim Start automatisch und
+    idempotent angewendet (`db/migrate.mjs`).
+  - Anmeldung: eigene Session-Verwaltung (opake, in der DB gespeicherte
+    Tokens, `httpOnly`/`sameSite=lax`-Cookie) statt Supabase Auth.
+    Passwörter werden mit Node-eigenem `crypto.scrypt` gehasht (keine
+    neue Abhängigkeit).
+  - Passkeys: `@simplewebauthn` ersetzt Supabase's bisher experimentelles
+    WebAuthn-API. Die RP-Domain wird direkt aus `APP_URL` abgeleitet –
+    kein externer Konfigurationsschritt mehr nötig.
+  - Logo/Favicon: lokale Dateiablage (Docker-Volume) statt
+    Supabase-Storage-Bucket, ausgeliefert über `/branding/[filename]`.
+  - Autorisierung (öffentlich lesbar / Kantinen-Team schreibt / nur
+    Admin für Einstellungen & Benutzer) läuft jetzt in den API-Routen
+    statt über Postgres-Row-Level-Security.
+  - E-Mail-Änderung im eigenen Konto läuft direkt nach
+    Passwort-Bestätigung statt über eine Supabase-Bestätigungsmail
+    (kein SMTP-Server vorhanden).
+- Datenbank startet beim allerersten Deployment leer; beim ersten Start
+  wird automatisch genau ein Admin-Benutzer mit zufällig generiertem
+  Passwort angelegt, die Zugangsdaten landen in `ZUGANGSDATEN.md`.
+
+### Behoben
+- „Mindestens 1 Passkey nötig, um die Passwort-Anmeldung zu
+  deaktivieren" wurde bisher nur clientseitig geprüft; ein manuell
+  gebauter Request hätte die Passwort-Anmeldung auch ohne Passkey
+  deaktivieren können. Jetzt zusätzlich serverseitig erzwungen.
+- Logo-/Favicon-Upload akzeptierte anhand des vom Browser gemeldeten
+  Dateityps auch SVG-Dateien. Da diese (anders als beim vorherigen
+  Supabase-Storage-Bucket auf fremder Domain) jetzt auf der eigenen
+  Origin ausgeliefert werden, hätte eine SVG mit eingebettetem
+  `<script>` bei direktem Aufruf der Datei-URL im Browser eines
+  anderen angemeldeten Admins ausgeführt werden können. Upload
+  akzeptiert jetzt nur noch eine Whitelist an Rasterformaten
+  (png/jpg/webp/gif/ico); vor dem Merge im Rahmen der
+  Sicherheitsprüfung gefunden und behoben.
+
+### Hinweis für bestehende Docker-Installationen
+Das Docker-Volume `pgdata` diente bisher nur als Lese-Kopie/Backup und
+wird mit v1.5 zur primären Datenbank. Es enthält noch das alte
+Supabase-Mirror-Schema und muss vor dem Upgrade entfernt werden
+(`docker compose down -v`, danach `docker compose up -d --build`), damit
+die neuen Migrationen auf einer leeren Datenbank laufen.
+
+## [1.4.0] – 2026-07-18
+
+### Hinzugefügt
+- Essenszeiten (Brotzeit/Mittagessen/…) vollständig verwaltbar: anlegen,
+  umbenennen (inkl. EN/PL), Uhrzeit ändern, löschen und per Pfeil-Buttons
+  neu anordnen – neue Seite „Essenszeiten" im Kantinen-Bereich. Löschen
+  entfernt zugewiesene Gerichte automatisch aus allen Wochenplänen.
+
+### Geändert
+- „Automatisch übersetzen"-Button bei Gerichten/Allergenen/Zusatzstoffen
+  ist nur noch sichtbar, wenn `DEEPL_API_KEY` gesetzt ist, statt erst
+  nach Klick auf die fehlende Konfiguration hinzuweisen.
+
+### Behoben
+- Sprachumschalter (DE/EN/PL) erschien auf der öffentlichen Speisekarte
+  in der mobilen Ansicht doppelt.
+
+## [1.3.0] – 2026-07-18
+
+### Hinzugefügt
+- Mehrsprachigkeit für die komplette Anwendung (Deutsch, Englisch,
+  Polnisch): Sprachumschalter (Cookie-basiert, kein Neuladen der
+  Seite nötig), sämtliche Oberflächentexte übersetzt
+- Gerichte, Bereiche, Allergene und Zusatzstoffe zusätzlich mit
+  englischem/polnischem Namen; öffentliche Speisekarte zeigt je nach
+  gewählter Sprache automatisch den passenden Namen (Fallback:
+  Deutsch, falls keine Übersetzung hinterlegt ist)
+- Automatische Übersetzung per DeepL: Button „Automatisch übersetzen“
+  beim Anlegen/Bearbeiten von Gerichten, Allergenen und Zusatzstoffen;
+  Ergebnis bleibt danach manuell korrigierbar. Aktivierung über die
+  neue Docker-Variable `DEEPL_API_KEY` – ohne Key bleibt der Button
+  inaktiv, die Felder lassen sich weiterhin von Hand ausfüllen
+- Rezeptvorschläge im öffentlichen Bereich: nicht angemeldete
+  Besucher können über „Rezept vorschlagen“ ein fehlendes Gericht
+  vorschlagen (Name + optionale Beschreibung), inkl. Dublettenprüfung
+  gegen bestehende Gerichte und einfachem Honeypot-Spamschutz
+- Neue Seite „Vorschläge“ im Kantinen-Bereich: eingereichte Vorschläge
+  sichten, als Gericht übernehmen oder ablehnen
+
+### Behoben
+- Passwort-wiederholen-Feld beim Bearbeiten eines Benutzers erschien
+  erst, nachdem im ersten Passwortfeld schon getippt wurde – wirkte
+  wie ein einzelnes Pflichtfeld
+- Anmelden-Button überlappte auf Mobilgeräten mit breiten Logos
+  (Banner-Format) das Logo, da er absolut in der oberen Ecke
+  positioniert war
+
+## [1.2.0] – 2026-07-18
+
+### Hinzugefügt
+- „Heute"-Button in der Wochennavigation (öffentliche Speisekarte und
+  Wochenplan-Editor)
+- Mobile Ansicht der öffentlichen Speisekarte: umschaltbar zwischen
+  Tag (Standard) und Woche, unabhängig von der Desktop-Tabelle
+- Allergene und Zusatzstoffe wieder pro Gericht auswählbar (Chip-Auswahl
+  im Formular) und als kleine Kürzel neben dem Gerichtnamen sichtbar –
+  in Speisekarte, mobiler Ansicht und Wochenplan-Editor
+- Passwort-Wiederholung beim Anlegen neuer Benutzer und beim optionalen
+  Passwort-Reset
+- Passwort-Anmeldung pro Konto deaktivierbar (nur wenn mindestens ein
+  Passkey registriert ist), Durchsetzung im Login-Flow
+- `SITE_TITLE`-Umgebungsvariable für Browser-Tab-Titel und Überschrift
+  ohne Logo
+- Austauschbares Favicon über den Admin-Design-Bereich
+
+### Geändert
+- Gemeinsame Navigation für Kantinen- und Admin-Bereich statt zwei
+  getrennter Menüs
+- Live-Suche bei den Gerichten
+- Mehrfachauswahl zum Batch-Löschen von Gerichten
+- App erreichbar auf `0.0.0.0` statt nur `localhost` (Docker und
+  nativer Betrieb)
+- Projekt umbenannt von „Speisekarte“ zu „canteen-menu“ (Docker-,
+  npm- und Supabase-Namen; deutsche In-App-Texte unverändert)
+- Öffentliche URL über `APP_URL` konfigurierbar (CSRF-Origin-Check
+  hinter Reverse-Proxy, Passkey-Domain)
+
+### Behoben
+- Next.js band `app/favicon.ico` zusätzlich zu einem dynamisch
+  gesetzten Favicon ein – Favicon wird jetzt immer explizit gesetzt
+- Weiterleitungen (Logout, Zugriffsschutz) übernahmen nach der
+  0.0.0.0-Bindung fälschlich die Server-Adresse statt des
+  aufgerufenen Hosts
+
+## [1.1.0] – 2026-07-17
+
+### Hinzugefügt
+- Versionsnummer im Fußbereich jeder Seite
+
+## [1.0.0] – 2026-07-17
+
+Erste vollständige Version.
+
+### Hinzugefügt
+- Öffentliche Speisekarte ohne Login: Wochenansicht Mo–Fr mit den
+  Bereichen Brotzeit, Mittagessen, Mittagessen vegetarisch und Suppe;
+  Wochen-Navigation; Logo zentriert; Allergene & Zusatzstoffe unterhalb
+  der Karte
+- Anmeldung mit E-Mail/Passwort oder Passkey
+- Kantinen-Bereich: Gerichte anlegen/bearbeiten/löschen, Wochenplan
+  pflegen, globale Allergen-/Zusatzstofflisten verwalten
+- Admin-Bereich: Benutzerverwaltung, Farbgebung, Logo-Upload
+- Eigenes Konto verwalten: Name, E-Mail, Passwort, Passkeys
+- Row-Level-Security, HTTP-Security-Header, CSRF-Origin-Check
+- Docker-Setup (App-Image, lokale PostgreSQL-Kopie, Dev-Profil ohne
+  lokales Node.js)
+- Lokale PostgreSQL-Kopie mit Sync-Skript
@@ -0,0 +1,276 @@
+# Deployment auf einem neuen Server
+
+Schritt-für-Schritt-Anleitung, um Canteen Menu auf einem frischen
+(Linux-)Server produktiv zu betreiben. Die App läuft vollständig selbst
+gehostet (PostgreSQL + eigene Auth), einzige optionale externe
+Abhängigkeit ist DeepL für automatische Übersetzungen.
+
+## Voraussetzungen
+
+- Ein Server (VM oder Root-Server) mit Docker und Docker Compose v2
+  (`docker compose version` sollte funktionieren; auf den meisten
+  aktuellen Distributionen per `apt install docker.io
+  docker-compose-v2` bzw. dem [offiziellen Docker-Install-Skript](https://docs.docker.com/engine/install/)
+  installierbar).
+- Eine Domain, deren DNS-A/AAAA-Eintrag auf die Server-IP zeigt (z. B.
+  `menu.example.de`). Ohne eigene Domain funktioniert die App auch
+  unter der reinen Server-IP, dann aber ohne gültiges HTTPS-Zertifikat
+  und ohne funktionierende Passkeys (siehe unten).
+- Mindestens 1 GB RAM frei (App + PostgreSQL sind genügsam, für ~250
+  Mitarbeiter reicht die kleinste übliche VM-Größe).
+
+## 1. Repository auf den Server holen
+
+```bash
+git clone https://github.com/<dein-fork-oder-repo>/canteen-menu.git
+cd canteen-menu
+```
+
+(Oder per `git pull`/`scp`, falls kein direkter Git-Zugriff vom Server
+aus gewünscht ist.)
+
+## 2. Konfiguration anlegen
+
+```bash
+cp .env.example .env.local
+```
+
+`.env.local` mit einem Editor öffnen und ausfüllen:
+
+| Variable | Was rein muss |
+| --- | --- |
+| `LOCAL_PG_PASSWORD` | Ein neues, zufälliges Passwort **nur aus Buchstaben/Zahlen** (z. B. `openssl rand -hex 24`) – wird beim ersten Start zum Datenbank-Passwort des mitgelieferten PostgreSQL-Containers. Zeichen wie `#`, `$`, Leerzeichen oder Anführungszeichen können beim Einlesen der `.env`-Datei zu Problemen führen (`#` beginnt z. B. einen Kommentar) |
+| `APP_URL` | Die öffentliche URL mit Schema, z. B. `https://menu.example.de` (auch wenn HTTPS erst in Schritt 5 eingerichtet wird – schon jetzt korrekt eintragen, da daraus u. a. die Passkey-Domain abgeleitet wird) |
+| `SITE_TITLE` | Optional, Titel im Browser-Tab/Überschrift ohne Logo |
+| `ADMIN_EMAIL` | Optional, E-Mail des automatisch angelegten Admin-Erstnutzers. Ohne Angabe: `admin@<Hostname aus APP_URL>` |
+| `DEEPL_API_KEY` | Optional, nur für automatische Übersetzung |
+
+`DATABASE_URL` in `.env.local` **nicht** anpassen – die wird nur für
+den Betrieb ohne Docker gebraucht (siehe README) und beim
+Docker-Compose-Start ignoriert.
+
+Zusätzlich eine leere Datei für die automatisch generierten
+Admin-Zugangsdaten anlegen, da sie per Bind-Mount in den Container
+eingebunden wird. Der App-Container läuft als nicht-root-Nutzer –
+damit er die Datei beschreiben darf, muss sie für alle schreibbar sein:
+
+```bash
+touch ZUGANGSDATEN.md
+chmod 666 ZUGANGSDATEN.md
+```
+
+## 3. App starten
+
+**Wichtig:** `.env.local` muss vollständig ausgefüllt sein, *bevor*
+dieser Befehl zum ersten Mal läuft – und danach immer mit
+`--env-file .env.local` aufgerufen werden. PostgreSQL setzt sein
+Passwort nur beim allerersten Start auf einem leeren Datenverzeichnis;
+läuft der Befehl vorher schon einmal ohne (oder mit einem anderen)
+`--env-file`, landet ein falsches Passwort dauerhaft im Datenbank-Volume
+(Symptom: `password authentication failed for user "postgres"` in den
+App-Logs, siehe [Fehlerbehebung](#fehlerbehebung)).
+
+```bash
+docker compose --env-file .env.local up -d --build
+```
+
+Das baut das Docker-Image, startet PostgreSQL und die App, wendet beim
+ersten Start automatisch das Datenbankschema an und legt – da die
+Datenbank leer ist – einen einzigen Admin-Benutzer mit zufällig
+generiertem Passwort an.
+
+Kurz prüfen, ob beides läuft:
+
+```bash
+docker compose ps
+docker compose logs app --tail 30
+```
+
+In den Logs sollte u. a. `bootstrap-admin – Admin angelegt: ...`
+stehen.
+
+## 4. Admin-Zugangsdaten abholen
+
+```bash
+cat ZUGANGSDATEN.md
+```
+
+Enthält E-Mail-Adresse und Passwort des automatisch angelegten
+Admin-Kontos. Direkt nach dem ersten Login unter „Mein Konto“ das
+Passwort ändern und optional einen Passkey registrieren.
+
+Die App ist jetzt unter `http://<server-ip>:3000` erreichbar – für den
+produktiven Betrieb fehlt noch HTTPS/die Domain (nächster Schritt).
+
+## 5. Reverse-Proxy + HTTPS einrichten
+
+Die App selbst spricht nur HTTP auf Port 3000; TLS/HTTPS übernimmt ein
+Reverse-Proxy davor. Am einfachsten mit [Caddy](https://caddyserver.com/)
+(automatisches Let’s-Encrypt-Zertifikat, keine manuelle Zertifikats-
+verwaltung nötig):
+
+```bash
+sudo apt install caddy   # oder: siehe caddyserver.com/docs/install
+```
+
+`/etc/caddy/Caddyfile`:
+
+```
+menu.example.de {
+    reverse_proxy localhost:3000
+}
+```
+
+```bash
+sudo systemctl reload caddy
+```
+
+Caddy holt beim ersten Aufruf automatisch ein Zertifikat und leitet
+danach HTTP→HTTPS um. Alternative: nginx + certbot, falls bereits ein
+nginx-Setup existiert (Standard-`proxy_pass`-Konfiguration auf
+`http://127.0.0.1:3000`, Zertifikat separat per `certbot --nginx`).
+
+Danach in `.env.local` sicherstellen, dass `APP_URL=https://menu.example.de`
+gesetzt ist (Schema `https`, keine Portangabe), und die App neu
+starten, falls diese Variable nach Schritt 2 noch geändert wurde:
+
+```bash
+docker compose --env-file .env.local up -d
+```
+
+## 6. Danach
+
+- Passkeys funktionieren erst mit korrekt gesetzter `APP_URL` (RP-Domain
+  wird direkt daraus abgeleitet) und über HTTPS (Passkeys verlangen eine
+  sichere Origin, `localhost` ausgenommen).
+- Weitere Kantinenmitarbeiter/Admins unter „Benutzer“ (nur als Admin
+  sichtbar) anlegen.
+- Essenszeiten, Gerichte, Allergene/Zusatzstoffe sind zu Beginn leer und
+  werden im Kantinen-Bereich gepflegt.
+- Logo/Favicon/Farben unter „Design“ (nur Admin) anpassen.
+
+## SSO/OpenID Connect (optional)
+
+Zusätzlich zu Passwort und Passkey kann ein SSO-Login gegen einen
+beliebigen OpenID-Connect-Provider aktiviert werden (z. B. ein selbst
+gehostetes [Authentik](https://goauthentik.io/)). Dazu in `.env.local`
+setzen:
+
+```bash
+OIDC_ISSUER=https://authentik.example.de/application/o/canteen-menu/
+OIDC_CLIENT_ID=<client-id-aus-authentik>
+OIDC_CLIENT_SECRET=<client-secret-aus-authentik>
+```
+
+Beim Identity Provider als Redirect-URI hinterlegen:
+`<APP_URL>/api/auth/oidc/callback` (also z. B.
+`https://menu.example.de/api/auth/oidc/callback`).
+
+**Wichtig:** SSO-Login funktioniert ausschließlich für E-Mail-Adressen,
+die bereits unter „Benutzer“ angelegt sind – es werden nie neue Konten
+angelegt, und die Rolle (Admin/Kantinenmitarbeiter) bleibt ausschließlich
+dort steuerbar. Ein Mitarbeiter muss also zuerst ganz normal als
+Benutzer angelegt werden, bevor er sich per SSO anmelden kann.
+
+Ohne die drei Variablen bleibt der SSO-Button auf der Anmeldeseite
+einfach ausgeblendet, Passwort/Passkey funktionieren unverändert.
+
+## Fehlerbehebung
+
+### `password authentication failed for user "postgres"` in den App-Logs
+
+Ursache: Das Docker-Volume der Datenbank wurde bereits mit einem
+anderen Passwort initialisiert, als aktuell in `.env.local` steht (z. B.
+weil `docker compose up` einmal ohne `--env-file .env.local` lief, bevor
+das Passwort gesetzt war, oder `LOCAL_PG_PASSWORD` nachträglich geändert
+wurde – PostgreSQL übernimmt das Passwort nur beim allerersten Start).
+
+Fix, solange noch keine echten Daten in der Datenbank sind (bei einem
+frischen Deployment immer der Fall):
+
+```bash
+docker compose --env-file .env.local down
+docker volume rm canteen-menu_pgdata
+docker compose --env-file .env.local up -d --build
+docker compose logs app --tail 30
+```
+
+Existieren bereits echte Daten, stattdessen das Passwort direkt im
+laufenden Datenbank-Container an `.env.local` angleichen, statt das
+Volume zu löschen:
+
+```bash
+docker compose exec db psql -U postgres -c "ALTER USER postgres WITH PASSWORD '<Wert aus LOCAL_PG_PASSWORD>';"
+docker compose --env-file .env.local up -d
+```
+
+### `Error: connect ECONNREFUSED ...:5432` beim Start
+
+Normal beim allerersten Start: Der App-Container versucht sich zu
+verbinden, bevor PostgreSQL im `db`-Container fertig hochgefahren ist.
+Dank `restart: unless-stopped` startet der App-Container automatisch
+neu und verbindet sich, sobald die Datenbank bereit ist (kann ein paar
+Sekunden bis wenige Minuten dauern). Mit `docker compose logs app -f`
+verfolgen – taucht der Fehler dauerhaft (mehrere Minuten) weiter auf,
+`docker compose ps` prüfen, ob der `db`-Container tatsächlich dauerhaft
+läuft.
+
+### `EACCES: permission denied, open '/app/ZUGANGSDATEN.md'`
+
+Die Datei wurde ohne Schreibrecht für alle angelegt (Schritt 2 oben,
+`chmod 666` fehlte). Der Admin-Benutzer wurde in diesem Fall trotzdem
+in der Datenbank angelegt, nur die Zugangsdaten konnten nicht in die
+Datei geschrieben werden – sie stehen dann stattdessen im Log
+(`docker compose logs app` nach `bootstrap-admin – Admin-Passwort:`
+durchsuchen). Für zukünftige Deployments zusätzlich die Berechtigung
+korrigieren:
+
+```bash
+chmod 666 ZUGANGSDATEN.md
+```
+
+Falls das Passwort auch im Log nicht mehr auffindbar ist (z. B. weil
+Logs schon rotiert wurden), Admin-Konto neu anlegen lassen:
+
+```bash
+docker compose exec db psql -U postgres -d canteen_menu -c "delete from users;"
+chmod 666 ZUGANGSDATEN.md
+docker compose restart app
+docker compose logs app --tail 20
+cat ZUGANGSDATEN.md
+```
+
+## Updates einspielen
+
+```bash
+git pull
+docker compose --env-file .env.local up -d --build
+```
+
+Neue Datenbank-Migrationen (`db/migrations/*.sql`) werden beim Start
+automatisch und idempotent angewendet, bestehende Daten bleiben
+erhalten.
+
+Alternativ übernimmt `./update.sh` den kompletten Ablauf: Stack stoppen,
+lokale Änderungen an `docker-compose.yml` per `git stash` sichern (falls
+vorhanden), `git pull`, Änderungen zurückspielen, Stack neu bauen und
+starten:
+
+```bash
+./update.sh
+```
+
+## Backup
+
+Zwei Docker-Volumes enthalten alle persistenten Daten:
+
+- `canteen-menu_pgdata` – die komplette PostgreSQL-Datenbank
+- `canteen-menu_branding_data` – hochgeladenes Logo/Favicon
+
+```bash
+docker run --rm -v canteen-menu_pgdata:/data -v "$PWD":/backup alpine \
+  tar czf /backup/pgdata-backup.tar.gz -C /data .
+```
+
+Für ein reines Datenbank-Backup eignet sich auch `docker compose exec db
+pg_dump -U postgres canteen_menu > backup.sql`.
@@ -15,12 +15,6 @@ WORKDIR /app
 COPY --from=deps /app/node_modules ./node_modules
 COPY . .

-# NEXT_PUBLIC_*-Variablen werden zur Build-Zeit ins Client-Bundle eingebacken
-ARG NEXT_PUBLIC_SUPABASE_URL
-ARG NEXT_PUBLIC_SUPABASE_ANON_KEY
-ENV NEXT_PUBLIC_SUPABASE_URL=$NEXT_PUBLIC_SUPABASE_URL
-ENV NEXT_PUBLIC_SUPABASE_ANON_KEY=$NEXT_PUBLIC_SUPABASE_ANON_KEY
-
 RUN npm run build

 # ---------- Runtime ----------
@@ -35,7 +29,13 @@ RUN addgroup -S nodejs && adduser -S nextjs -G nodejs
 COPY --from=builder /app/public ./public
 COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
 COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
+# Von Next's Standalone-Output nicht automatisch mitgetraced (werden nicht
+# von App-Routen importiert, sondern eigenständig vor dem Start ausgeführt).
+COPY --from=builder --chown=nextjs:nodejs /app/db ./db
+COPY --from=builder --chown=nextjs:nodejs /app/scripts ./scripts
+
+RUN mkdir -p /data/branding && chown nextjs:nodejs /data/branding

 USER nextjs
 EXPOSE 3000
-CMD ["node", "server.js"]
+CMD ["sh", "-c", "node db/migrate.mjs && node scripts/bootstrap-admin.mjs && exec node server.js"]
@@ -4,36 +4,70 @@ Digitale Speisekarte für eine Firmenkantine (ca. 250 Mitarbeiter) mit
 öffentlicher Wochenansicht, Kantinen-Bereich zur Pflege der Gerichte und
 Admin-Bereich für Benutzerverwaltung und Branding.

-**Stack:** Next.js 16 (App Router, TypeScript, Tailwind CSS) · Supabase
-(PostgreSQL, Auth inkl. Passkeys, Storage, Row Level Security)
+**Stack:** Next.js 16 (App Router, TypeScript, Tailwind CSS) · selbst
+gehostetes PostgreSQL (via `pg`, eigene Migrationen) · eigene Session-Auth
+(Passwort via `node:crypto` scrypt, Passkeys via `@simplewebauthn`) ·
+DeepL als einzige externe API (optional). Läuft vollständig selbst
+gehostet, keine Cloud-Abhängigkeit außer optional DeepL.
+
+Änderungen je Version stehen in [CHANGELOG.md](CHANGELOG.md), Git-Tags
+markieren die jeweiligen Versionsstände (`git tag`). Schritt-für-Schritt-
+Anleitung für die Inbetriebnahme auf einem neuen Server:
+[DEPLOYMENT.md](DEPLOYMENT.md).

 ## Funktionen

 | Bereich | Funktionen |
 | --- | --- |
-| Öffentlich (ohne Login) | Wochenplan Mo–Fr mit den Bereichen Brotzeit (09:00–10:00), Mittagessen, Mittagessen vegetarisch und Suppe (je 11:30–13:30); Navigation vorherige/nächste Woche; Logo zentriert über der Karte; Allergene & Zusatzstoffe unterhalb der Karte |
-| Kantinen-Team (`/intern`) | Gerichte anlegen/bearbeiten/löschen; Gerichte Tagen/Bereichen zuweisen (mehrere pro Zelle) und wieder entfernen; globale Allergen-/Zusatzstofflisten pflegen; eigene Passkeys verwalten |
-| Admin (`/admin`) | Kantinenmitarbeiter anlegen/bearbeiten/löschen (inkl. Passwort-Reset und Rollenvergabe); Farbgebung der Speisekarte anpassen; Logo hochladen/entfernen |
+| Öffentlich (ohne Login) | Wochenplan Mo–Fr mit frei konfigurierbaren Essenszeiten; Navigation vorherige/nächste Woche/Heute; auf schmalen Bildschirmen umschaltbare Tages-/Wochenansicht (Tag ist Standard); Logo zentriert über der Karte; Allergen-/Zusatzstoff-Kürzel je Gericht, Legende unterhalb der Karte; Sprachumschalter Deutsch/Englisch/Polnisch; Rezeptvorschläge einreichen; RSS-Feed (`/feed.xml`, Icon im Kopfbereich) mit einem Eintrag pro Tag zum Abonnieren |
+| Kantinen-Team (`/intern`) | Essenszeiten anlegen/bearbeiten/löschen/neu anordnen; Gerichte anlegen/bearbeiten/löschen (inkl. Live-Suche, Mehrfachauswahl zum Batch-Löschen, englischem/polnischem Namen mit automatischer DeepL-Übersetzung) mit Allergenen/Zusatzstoffen je Gericht; Gerichte per Suche Tagen/Essenszeiten zuweisen (mehrere pro Zelle) und wieder entfernen; globale Allergen-/Zusatzstofflisten pflegen (ebenfalls mehrsprachig); eingereichte Rezeptvorschläge sichten, übernehmen oder ablehnen (Anzahl offener Vorschläge als Badge in der Navigation); eigenes Konto verwalten (Name, E-Mail, Passwort, Passkeys, Passwort-Anmeldung an/aus) |
+| Admin (`/admin`) | Kantinenmitarbeiter anlegen/bearbeiten/löschen (inkl. Passwort-Reset mit Wiederholung und Rollenvergabe); Farbgebung der Speisekarte anpassen; Logo und Favicon hochladen/entfernen |

 Anmeldung mit E-Mail + Passwort oder alternativ per **Passkey**
-(Registrierung im Bereich „Passkeys“ nach dem ersten Login).
+(Registrierung im eigenen Konto nach dem ersten Login). Die
+Passwort-Anmeldung kann pro Konto deaktiviert werden, sobald mindestens
+ein Passkey registriert ist (serverseitig erzwungen).
+
+Die gesamte Oberfläche ist auf Deutsch, Englisch und Polnisch verfügbar
+(Sprachumschalter, Cookie-basiert). Gerichte, Essenszeiten, Allergene und
+Zusatzstoffe lassen sich zusätzlich auf Englisch/Polnisch benennen –
+mit optionaler automatischer Übersetzung über DeepL (siehe
+`DEEPL_API_KEY` unten) und jederzeit manuell korrigierbar.

 ## Projektstruktur

 ```
 app/                    Next.js-Routen
  page.tsx              Öffentliche Speisekarte
+  feed.xml/              RSS-Feed des Speiseplans (öffentlich)
  login/                Login (Passwort + Passkey)
+  vorschlag/             Öffentliches Rezeptvorschlag-Formular
  intern/               Kantinen-Bereich (Rolle: staff oder admin)
+    vorschlaege/         Rezeptvorschläge sichten/übernehmen
  admin/                Verwaltung (Rolle: admin)
-  api/admin/users/      Benutzerverwaltung (serverseitig, Service-Role-Key)
+  branding/[filename]/   Logo/Favicon ausliefern (öffentlich)
+  api/auth/              Login, Logout, Passkeys
+  api/account/           Eigenes Konto (Name, E-Mail, Passwort, Toggle)
+  api/admin/users/       Benutzerverwaltung (nur Admin)
+  api/admin/branding/    Logo-/Favicon-Upload (nur Admin)
+  api/dishes/, api/sections/, api/allergens/, api/additives/,
+  api/menu-entries/, api/dish-suggestions/, api/settings/
+                          CRUD-Routen für den Kantinen-/Admin-Bereich
+  api/translate/          DeepL-Anbindung (serverseitig)
+  api/locale/             Sprach-Cookie setzen
 components/             Client-Komponenten (WeekEditor, DishManager, …)
-lib/supabase/           Supabase-Clients (Browser / Server / Admin)
+components/i18n/        Sprachkontext, Sprachumschalter
+lib/i18n/               Wörterbücher (de/en/pl), Locale-Helfer
+lib/auth/               Sessions, Passwort-Hashing, WebAuthn-Konfiguration
+lib/db/                 pg-Pool, Query-Helfer, gemeinsame Ladefunktionen
+lib/branding.ts         Lokale Datei-Ablage für Logo/Favicon
 lib/                    Typen, Datums-/Formatierungshelfer
-proxy.ts                Session-Refresh + Schutz von /intern und /admin
-supabase/migrations/    Schema & Seed-Daten (Referenz/Doku)
-supabase/local/         Skripte + Dumps für die lokale PostgreSQL-Kopie
-scripts/                Hilfsskripte (DB-Migration, lokaler Sync)
+proxy.ts                Session-Prüfung + Schutz von /intern, /admin, /konto
+db/migrations/          Datenbankschema (reines SQL, nummeriert)
+db/migrate.mjs          Wendet neue Migrationen an (idempotent, bei jedem Start)
+scripts/bootstrap-admin.mjs
+                        Legt bei leerer Datenbank automatisch einen
+                        Admin mit Zufallspasswort an (siehe ZUGANGSDATEN.md)
 ```

 ## Entwicklung
@@ -49,24 +83,26 @@ docker compose --env-file .env.local --profile dev up dev
 # http://localhost:3000 (Hot-Reload, Quellcode wird gemountet)
 ```

-**Variante B – lokal installiertes Node.js:**
+**Variante B – lokal installiertes Node.js + PostgreSQL:**

 ```bash
 npm install
 npm run dev            # http://localhost:3000 (bindet an 0.0.0.0, auch im LAN erreichbar)
 ```

-## Umgebungsvariablen (Live-Betrieb)
+In beiden Varianten wird die Datenbank beim Start automatisch auf den
+neuesten Stand migriert und – falls noch kein Benutzer existiert – ein
+Admin-Konto mit Zufallspasswort angelegt (siehe [Zugangsdaten](#zugangsdaten)).

-Beim Webserver/Hoster müssen genau diese drei Variablen hinterlegt werden
-(Werte: Supabase-Dashboard → Project Settings → API Keys):
+## Umgebungsvariablen (Live-Betrieb)

 | Variable | Bedeutung | Geheim? |
 | --- | --- | --- |
-| `NEXT_PUBLIC_SUPABASE_URL` | URL des Supabase-Projekts, z. B. `https://hvzikwjoyhoakedlywhj.supabase.co` | nein |
-| `NEXT_PUBLIC_SUPABASE_ANON_KEY` | Öffentlicher anon-Key (RLS schützt die Daten) | nein |
-| `SUPABASE_SERVICE_ROLE_KEY` | Service-Role-Key für die Benutzerverwaltung | **ja – niemals im Browser/Repo!** |
-| `APP_URL` | Öffentliche URL der App, z. B. `https://menu.example.de` (Origin-Check hinter Reverse-Proxy; zugleich Passkey-Domain) | nein |
+| `DATABASE_URL` | Verbindung zur PostgreSQL-Datenbank, z. B. `postgres://postgres:<passwort>@db:5432/canteen_menu` | **ja** |
+| `APP_URL` | Öffentliche URL der App, z. B. `https://menu.example.de` (Origin-Check hinter Reverse-Proxy; zugleich Passkey-RP-Domain – wird direkt daraus abgeleitet, kein separater Konfigurationsschritt nötig) | nein |
+| `SITE_TITLE` | Titel im Browser-Tab und Überschrift ohne Logo, Default `Canteen Menu` | nein |
+| `ADMIN_EMAIL` | Optional: E-Mail des automatisch angelegten Admin-Erstnutzers (nur relevant, solange die Datenbank leer ist). Ohne Angabe: `admin@<Hostname aus APP_URL>` | nein |
+| `DEEPL_API_KEY` | Optional: aktiviert „Automatisch übersetzen“ für Gerichte/Allergene/Zusatzstoffe (DeepL, kostenloser Free-Tier). Ohne Key funktioniert alles weiter, nur automatisch übersetzen ist deaktiviert | **ja – niemals im Browser/Repo!** |

 Build & Start auf dem Server – **mit Docker** (empfohlen, Node.js und
 PostgreSQL müssen nicht installiert sein):
@@ -74,10 +110,15 @@ PostgreSQL müssen nicht installiert sein):
 ```bash
 docker compose --env-file .env.local up -d --build
 # App: Port 3000 (hinter Reverse-Proxy mit HTTPS betreiben)
-# Lokale DB-Kopie: Port 5433 (Dienst "db", optional)
+# PostgreSQL: kein Host-Port, nur intern im Compose-Netzwerk erreichbar
 ```

-Oder klassisch ohne Docker:
+Vor dem ersten Start: eine leere `ZUGANGSDATEN.md` im Projektverzeichnis
+anlegen (`touch ZUGANGSDATEN.md`), da diese Datei per Bind-Mount in den
+Container eingebunden wird und die automatisch generierten Admin-
+Zugangsdaten dort landen.
+
+Oder klassisch ohne Docker (mit lokal erreichbarem PostgreSQL):

 ```bash
 npm ci
@@ -85,71 +126,39 @@ npm run build
 npm run start           # Port 3000, bindet an 0.0.0.0 (hinter Reverse-Proxy betreiben)
 ```

-### Passkeys für die Produktions-Domain freischalten
-
-Passkeys sind an die Domain gebunden. Aktuell ist `localhost` konfiguriert.
-Vor dem Livegang: `APP_URL` auf die öffentliche URL setzen und einmalig
-
-```bash
-SUPABASE_ACCESS_TOKEN=<personal-access-token> node scripts/configure-passkeys.mjs
-```
-
-ausführen (liest `APP_URL` aus der Umgebung; die URL kann alternativ als
-Argument übergeben werden). Ohne lokales Node.js geht es auch über Docker:
-
-```bash
-docker run --rm -v .:/app -w /app \
-  -e SUPABASE_ACCESS_TOKEN=<token> -e APP_URL=https://menu.example.de \
-  node:24-alpine node scripts/configure-passkeys.mjs
-```
-
-Achtung: Bereits registrierte Passkeys der alten Domain verlieren dabei
-ihre Gültigkeit und müssen neu registriert werden.
+Passkeys sind an die Domain gebunden (RP-ID = Hostname aus `APP_URL`).
+Vor dem Livegang `APP_URL` auf die öffentliche URL setzen – ein
+zusätzlicher Konfigurationsschritt ist nicht nötig. Bereits registrierte
+Passkeys einer vorherigen Domain verlieren dabei ihre Gültigkeit und
+müssen neu registriert werden.

 ## Datenbank

-### Supabase (führende Datenbank)
+Reines, selbst gehostetes PostgreSQL (keine Row-Level-Security-Policies) –
+alle Zugriffsrechte werden in den Route-Handlern geprüft (`lib/auth/session.ts`,
+`requireRole`).

- Projekt-Ref: `hvzikwjoyhoakedlywhj` (Region `eu-central-1`, Frankfurt)
- Schema und Seed-Daten: `supabase/migrations/0001_init.sql` und `0002_seed.sql`
- Ausführen weiterer SQL-Dateien:
-  `SUPABASE_ACCESS_TOKEN=<token> node scripts/db-apply.mjs <datei.sql>`
+- Schema: `db/migrations/*.sql`, nummeriert, wird von `db/migrate.mjs`
+  automatisch angewendet (idempotent, bei jedem Start des Servers bzw.
+  Docker-Containers).
+- Neue Migration hinzufügen: `db/migrations/000N_beschreibung.sql`
+  anlegen, wird beim nächsten Start automatisch eingespielt.
+- Manuell migrieren: `npm run db:migrate`

-Sicherheitsmodell (Row Level Security):
+Rechte-Modell (in Anwendungscode statt Datenbank-RLS):

- `anon` darf ausschließlich lesen (Speisekarte, Bereiche, Allergene,
-  Zusatzstoffe, Einstellungen).
- `staff`/`admin` (Rolle im `profiles`-Eintrag) pflegen Gerichte,
-  Wochenplan und Kennzeichnungen.
- Nur `admin` ändert Einstellungen (Farben/Logo) und verwaltet Benutzer;
-  das Anlegen/Löschen von Benutzern läuft serverseitig über den
-  Service-Role-Key (`app/api/admin/users`).
- Storage-Bucket `branding` (Logo): öffentlich lesbar, Schreibzugriff nur Admin.
-
-### Lokale PostgreSQL-Kopie
-
-Die Datenbank `canteen_menu` (Kopie von Schema + Daten aus Supabase, inkl.
-Minimal-Stubs für `auth`/`storage`) gibt es in zwei Varianten:
-
-**Per Docker:** Der Dienst `db` aus `docker-compose.yml` spielt die
-Skripte aus `supabase/local/` beim ersten Start automatisch ein
-(PostgreSQL 17, Host-Port 5433 – 5432 ist meist durch eine native
-PostgreSQL-Installation belegt –, Passwort über `LOCAL_PG_PASSWORD`).
-
-**Nativ:** Auf dem Entwicklungsrechner läuft PostgreSQL 17 mit derselben
-Datenbank. Neu aufbauen bzw. aktualisieren:
-
-```powershell
-$env:SUPABASE_DB_PASSWORD = "<Supabase-DB-Passwort>"
-$env:LOCAL_PG_PASSWORD    = "<lokales postgres-Passwort>"
-powershell -File scripts\sync-local-db.ps1
-```
-
-Hinweis: Die lokale Kopie dient als Ablage/Backup und für Auswertungen.
-Logins (Passwort-Hashes, Passkeys) verbleiben ausschließlich in Supabase.
+- Öffentlich lesbar (kein Login nötig): Speisekarte, Essenszeiten,
+  Allergene, Zusatzstoffe, Logo/Favicon.
+- `staff`/`admin` pflegen Gerichte, Essenszeiten, Wochenplan und
+  Kennzeichnungen.
+- Nur `admin` ändert Einstellungen (Farben/Logo) und verwaltet Benutzer.
+- Logo/Favicon liegen als Dateien in `BRANDING_DIR` (Docker-Volume
+  `branding_data`), öffentlich ausgeliefert über `/branding/[filename]`.

 ## Zugangsdaten

-Die Anmeldedaten (Admin, Demo-Mitarbeiter, Datenbank-Passwörter) stehen in
-`ZUGANGSDATEN.md` – diese Datei ist bewusst **nicht** im Repository
-(`.gitignore`). Nach dem ersten Login bitte die Startpasswörter ändern.
+Beim allerersten Start mit leerer Datenbank legt `scripts/bootstrap-admin.mjs`
+automatisch einen Admin-Benutzer mit zufällig generiertem Passwort an und
+schreibt die Zugangsdaten nach `ZUGANGSDATEN.md` – diese Datei ist bewusst
+**nicht** im Repository (`.gitignore`). Nach dem ersten Login bitte das
+Startpasswort ändern.
@@ -1,5 +1,5 @@
 import { redirect } from "next/navigation";
-import { createClient } from "@/lib/supabase/server";
+import { getSession } from "@/lib/auth/session";
 import AppHeader from "@/components/AppHeader";

 export default async function AdminLayout({
@@ -7,24 +7,15 @@ export default async function AdminLayout({
 }: {
  children: React.ReactNode;
 }) {
-  const supabase = await createClient();
-  const {
-    data: { user },
-  } = await supabase.auth.getUser();
-  if (!user) redirect("/login");
-
-  const { data: profile } = await supabase
-    .from("profiles")
-    .select("role, full_name")
-    .eq("id", user.id)
-    .single();
-  if (profile?.role !== "admin") redirect("/intern");
+  const session = await getSession();
+  if (!session) redirect("/login");
+  if (session.user.role !== "admin") redirect("/intern");

  return (
    <div className="flex-1 flex flex-col">
      <AppHeader
        role="admin"
-        displayName={profile.full_name || user.email || ""}
+        displayName={session.user.full_name || session.user.email}
      />
      <main className="max-w-[1600px] mx-auto w-full px-4 py-6 flex-1">
        {children}
@@ -1,5 +1,7 @@
+import { getSession } from "@/lib/auth/session";
 import UserManager from "@/components/UserManager";

-export default function AdminPage() {
-  return <UserManager />;
+export default async function AdminPage() {
+  const session = await getSession();
+  return <UserManager meId={session?.user.id ?? ""} />;
 }
@@ -0,0 +1,5 @@
+import LanguageManager from "@/components/LanguageManager";
+
+export default function LanguagesPage() {
+  return <LanguageManager />;
+}
@@ -0,0 +1,50 @@
+import { NextResponse } from "next/server";
+import { query, queryOne } from "@/lib/db";
+import { verifyPassword } from "@/lib/auth/password";
+import { requireSession, UnauthorizedError } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+// Ändert die E-Mail-Adresse direkt nach Passwort-Bestätigung – ohne
+// Bestätigungsmail, da kein SMTP-Server betrieben wird.
+export async function PATCH(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    const session = await requireSession();
+    const { email, password } = (await request.json().catch(() => ({}))) as {
+      email?: string;
+      password?: string;
+    };
+    if (!email || !password) {
+      return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+    }
+
+    const user = await queryOne<{ password_hash: string }>(
+      "select password_hash from users where id = $1",
+      [session.user.id]
+    );
+    if (!user || !verifyPassword(password, user.password_hash)) {
+      return NextResponse.json({ error: "wrong_password" }, { status: 401 });
+    }
+
+    try {
+      await query("update users set email = $1 where id = $2", [
+        email.trim().toLowerCase(),
+        session.user.id,
+      ]);
+    } catch (err) {
+      if (err instanceof Error && /unique/i.test(err.message)) {
+        return NextResponse.json({ error: "email_used" }, { status: 409 });
+      }
+      throw err;
+    }
+
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    if (err instanceof UnauthorizedError) {
+      return NextResponse.json({ error: "unauthorized" }, { status: 401 });
+    }
+    throw err;
+  }
+}
@@ -0,0 +1,41 @@
+import { NextResponse } from "next/server";
+import { query, queryOne } from "@/lib/db";
+import { hashPassword, verifyPassword } from "@/lib/auth/password";
+import { requireSession, UnauthorizedError } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function PATCH(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    const session = await requireSession();
+    const { currentPassword, newPassword } = (await request.json().catch(() => ({}))) as {
+      currentPassword?: string;
+      newPassword?: string;
+    };
+    if (!currentPassword || !newPassword || newPassword.length < 8) {
+      return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+    }
+
+    const user = await queryOne<{ password_hash: string }>(
+      "select password_hash from users where id = $1",
+      [session.user.id]
+    );
+    if (!user || !verifyPassword(currentPassword, user.password_hash)) {
+      return NextResponse.json({ error: "wrong_password" }, { status: 401 });
+    }
+
+    await query("update users set password_hash = $1 where id = $2", [
+      hashPassword(newPassword),
+      session.user.id,
+    ]);
+
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    if (err instanceof UnauthorizedError) {
+      return NextResponse.json({ error: "unauthorized" }, { status: 401 });
+    }
+    throw err;
+  }
+}
@@ -0,0 +1,50 @@
+import { NextResponse } from "next/server";
+import { query, queryOne } from "@/lib/db";
+import { requireSession, UnauthorizedError } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+// Nimmt bewusst NUR full_name/password_auth_enabled aus dem Body an –
+// ersetzt den früheren Postgres-Column-Grant, der self-service-Updates
+// auf "role"/"email" verhindert hat. Ein generisches "update the whole
+// body"-Endpoint würde diese Absicherung wieder aufheben.
+export async function PATCH(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    const session = await requireSession();
+    const body = (await request.json().catch(() => ({}))) as {
+      full_name?: string;
+      password_auth_enabled?: boolean;
+    };
+
+    if (body.password_auth_enabled === false) {
+      const passkeys = await queryOne<{ count: string }>(
+        "select count(*)::int as count from passkey_credentials where user_id = $1",
+        [session.user.id]
+      );
+      if (!passkeys || Number(passkeys.count) === 0) {
+        return NextResponse.json({ error: "needs_passkey" }, { status: 400 });
+      }
+    }
+
+    if (body.full_name !== undefined) {
+      const name = body.full_name.trim();
+      if (!name) return NextResponse.json({ error: "name_required" }, { status: 400 });
+      await query("update users set full_name = $1 where id = $2", [name, session.user.id]);
+    }
+    if (body.password_auth_enabled !== undefined) {
+      await query("update users set password_auth_enabled = $1 where id = $2", [
+        body.password_auth_enabled,
+        session.user.id,
+      ]);
+    }
+
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    if (err instanceof UnauthorizedError) {
+      return NextResponse.json({ error: "unauthorized" }, { status: 401 });
+    }
+    throw err;
+  }
+}
@@ -0,0 +1,47 @@
+import { NextResponse } from "next/server";
+import { deleteCode, updateCode } from "@/lib/db/code-lists";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function PATCH(
+  request: Request,
+  { params }: { params: Promise<{ code: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { code } = await params;
+    const body = await request.json();
+    const item = await updateCode("additives", code, body);
+    if (!item) return NextResponse.json({ error: "not_found" }, { status: 404 });
+    return NextResponse.json(item);
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    if (err instanceof Error && /duplicate key/i.test(err.message)) {
+      return NextResponse.json({ error: "duplicate_code" }, { status: 409 });
+    }
+    throw err;
+  }
+}
+
+export async function DELETE(
+  request: Request,
+  { params }: { params: Promise<{ code: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { code } = await params;
+    await deleteCode("additives", code);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,29 @@
+import { listCodes } from "@/lib/db/code-lists";
+import { listActiveLanguageCodes } from "@/lib/db/languages";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { toCsv } from "@/lib/csv";
+
+export async function GET() {
+  try {
+    await requireRole(["staff", "admin"]);
+    const [items, activeCodes] = await Promise.all([
+      listCodes("additives"),
+      listActiveLanguageCodes(),
+    ]);
+    const langCodes = activeCodes.filter((c) => c !== "de");
+    const rows = [
+      ["code", "name", ...langCodes.map((c) => `name_${c}`)],
+      ...items.map((i) => [i.code, i.name, ...langCodes.map((c) => i.translations[c] ?? "")]),
+    ];
+    return new Response(toCsv(rows), {
+      headers: {
+        "Content-Type": "text/csv; charset=utf-8",
+        "Content-Disposition": 'attachment; filename="zusatzstoffe.csv"',
+      },
+    });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,56 @@
+import { NextResponse } from "next/server";
+import { importCodes, type CodeImportRow } from "@/lib/db/code-lists";
+import { listActiveLanguageCodes } from "@/lib/db/languages";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+import { parseCsvWithHeader } from "@/lib/csv";
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const form = await request.formData();
+    const file = form.get("file");
+    if (!(file instanceof File)) {
+      return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+    }
+
+    const { header, rows: cells } = parseCsvWithHeader(await file.text());
+    const codeIdx = header.indexOf("code");
+    const nameIdx = header.indexOf("name");
+    if (codeIdx === -1 || nameIdx === -1) {
+      return NextResponse.json({ error: "missing_columns" }, { status: 400 });
+    }
+    const activeCodes = (await listActiveLanguageCodes()).filter((c) => c !== "de");
+    const langCols = activeCodes
+      .map((code) => ({ code, idx: header.indexOf(`name_${code}`) }))
+      .filter((c) => c.idx !== -1);
+
+    const rows: CodeImportRow[] = [];
+    const skipped: { row: number; reason: string }[] = [];
+    cells.forEach((c, i) => {
+      const rowNum = i + 2; // 1-indexiert + Kopfzeile
+      const code = (c[codeIdx] ?? "").trim();
+      const name = (c[nameIdx] ?? "").trim();
+      if (!code || !name) {
+        skipped.push({ row: rowNum, reason: "Kürzel oder Bezeichnung fehlt" });
+        return;
+      }
+      const translations: Record<string, string> = {};
+      for (const { code: lang, idx } of langCols) {
+        const value = c[idx]?.trim();
+        if (value) translations[lang] = value;
+      }
+      rows.push({ code, name, translations });
+    });
+
+    const result = rows.length > 0 ? await importCodes("additives", rows) : { created: 0, updated: 0 };
+    return NextResponse.json({ ...result, skipped });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,27 @@
+import { NextResponse } from "next/server";
+import { createCode, listCodes } from "@/lib/db/code-lists";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function GET() {
+  return NextResponse.json(await listCodes("additives"));
+}
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const body = await request.json();
+    const item = await createCode("additives", body);
+    return NextResponse.json(item, { status: 201 });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    if (err instanceof Error && /duplicate key/i.test(err.message)) {
+      return NextResponse.json({ error: "duplicate_code" }, { status: 409 });
+    }
+    throw err;
+  }
+}
@@ -0,0 +1,92 @@
+import { NextResponse } from "next/server";
+import { queryOne, query } from "@/lib/db";
+import { removeBrandingFile, saveBrandingFile } from "@/lib/branding";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+type AssetKind = "logo" | "favicon";
+const ASSET_COLUMN: Record<AssetKind, "logo_path" | "favicon_path"> = {
+  logo: "logo_path",
+  favicon: "favicon_path",
+};
+
+function isAssetKind(value: unknown): value is AssetKind {
+  return value === "logo" || value === "favicon";
+}
+
+// Whitelist statt "image/*": svg absichtlich ausgeschlossen. Eine SVG
+// mit eingebettetem <script> würde als image/svg+xml auf der eigenen
+// Origin ausgeliefert und bei direktem Aufruf der Datei-URL ausgeführt
+// (inkl. Session-Cookie) – anders als Rasterformate. Die Dateiendung
+// wird aus dem geprüften MIME-Typ abgeleitet statt aus dem vom Client
+// gesendeten Dateinamen, damit der gespeicherte Dateiname nicht vom
+// Client bestimmt wird.
+const ALLOWED_IMAGE_TYPES: Record<string, string> = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp",
+  "image/gif": "gif",
+  "image/x-icon": "ico",
+  "image/vnd.microsoft.icon": "ico",
+};
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["admin"]);
+    const form = await request.formData();
+    const kind = form.get("kind");
+    const file = form.get("file");
+    if (!isAssetKind(kind) || !(file instanceof File)) {
+      return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+    }
+    const ext = ALLOWED_IMAGE_TYPES[file.type];
+    if (!ext) {
+      return NextResponse.json({ error: "invalid_image" }, { status: 400 });
+    }
+
+    const old = await queryOne<{ path: string | null }>(
+      `select ${ASSET_COLUMN[kind]} as path from settings where id = 1`
+    );
+
+    const filename = `${kind}-${Date.now()}.${ext}`;
+    const buffer = Buffer.from(await file.arrayBuffer());
+    await saveBrandingFile(filename, buffer);
+
+    await query(`update settings set ${ASSET_COLUMN[kind]} = $1 where id = 1`, [filename]);
+    if (old?.path) await removeBrandingFile(old.path);
+
+    return NextResponse.json({ path: filename });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
+
+export async function DELETE(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["admin"]);
+    const { kind } = (await request.json()) as { kind?: unknown };
+    if (!isAssetKind(kind)) {
+      return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+    }
+
+    const old = await queryOne<{ path: string | null }>(
+      `select ${ASSET_COLUMN[kind]} as path from settings where id = 1`
+    );
+    await query(`update settings set ${ASSET_COLUMN[kind]} = null where id = 1`);
+    if (old?.path) await removeBrandingFile(old.path);
+
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,52 @@
+import { NextResponse } from "next/server";
+import { getLanguage, importTranslations } from "@/lib/db/languages";
+import { currentTemplateHash, validateImport } from "@/lib/i18n/template";
+import { ForbiddenError, requireRole, UnauthorizedError } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ code: string }> }
+) {
+  try {
+    if (!isSameOrigin(request)) throw new ForbiddenError();
+    await requireRole(["admin"]);
+  } catch (err) {
+    if (err instanceof UnauthorizedError || err instanceof ForbiddenError) {
+      return NextResponse.json({ error: "Nicht berechtigt." }, { status: 403 });
+    }
+    throw err;
+  }
+
+  const { code } = await params;
+  const language = await getLanguage(code);
+  if (!language) {
+    return NextResponse.json({ error: "not_found" }, { status: 404 });
+  }
+  if (language.is_base) {
+    return NextResponse.json({ error: "cannot_import_base" }, { status: 400 });
+  }
+
+  const form = await request.formData();
+  const file = form.get("file");
+  if (!(file instanceof File)) {
+    return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(await file.text());
+  } catch {
+    return NextResponse.json({ error: "invalid_json" }, { status: 400 });
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return NextResponse.json({ error: "invalid_json" }, { status: 400 });
+  }
+
+  const { entries, skipped } = validateImport(parsed as Record<string, unknown>);
+  if (entries.length > 0) {
+    await importTranslations(code, entries, currentTemplateHash());
+  }
+
+  return NextResponse.json({ imported: entries.length, skipped });
+}
@@ -0,0 +1,75 @@
+import { NextResponse } from "next/server";
+import {
+  deleteLanguage,
+  setLanguageActive,
+  updateLanguageLabel,
+} from "@/lib/db/languages";
+import { ForbiddenError, requireRole, UnauthorizedError } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+async function requireAdmin(request: Request) {
+  if (!isSameOrigin(request)) throw new ForbiddenError();
+  return requireRole(["admin"]);
+}
+
+function errorResponse(err: unknown) {
+  if (err instanceof UnauthorizedError || err instanceof ForbiddenError) {
+    return NextResponse.json({ error: "Nicht berechtigt." }, { status: 403 });
+  }
+  return null;
+}
+
+export async function PATCH(
+  request: Request,
+  { params }: { params: Promise<{ code: string }> }
+) {
+  try {
+    await requireAdmin(request);
+  } catch (err) {
+    const res = errorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+
+  const { code } = await params;
+  const body = await request.json().catch(() => null);
+
+  try {
+    if (typeof body?.active === "boolean") {
+      await setLanguageActive(code, body.active);
+    }
+    if (typeof body?.label === "string" && body.label.trim()) {
+      await updateLanguageLabel(code, body.label.trim());
+    }
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    if (err instanceof Error && err.message === "cannot_deactivate_last") {
+      return NextResponse.json({ error: "cannot_deactivate_last" }, { status: 400 });
+    }
+    throw err;
+  }
+}
+
+export async function DELETE(
+  request: Request,
+  { params }: { params: Promise<{ code: string }> }
+) {
+  try {
+    await requireAdmin(request);
+  } catch (err) {
+    const res = errorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+
+  const { code } = await params;
+  try {
+    await deleteLanguage(code);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    if (err instanceof Error && err.message === "cannot_delete_base") {
+      return NextResponse.json({ error: "cannot_delete_base" }, { status: 400 });
+    }
+    throw err;
+  }
+}
@@ -0,0 +1,96 @@
+import { NextResponse } from "next/server";
+import {
+  createLanguage,
+  listLanguages,
+  listTranslations,
+} from "@/lib/db/languages";
+import { computeCompleteness, currentTemplateHash } from "@/lib/i18n/template";
+import { ForbiddenError, requireRole, UnauthorizedError } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+// Sprachverwaltung (nur Admin) – gleiches Auth-/CSRF-Muster wie
+// app/api/admin/users/route.ts.
+
+async function requireAdmin(request: Request) {
+  if (!isSameOrigin(request)) throw new ForbiddenError();
+  return requireRole(["admin"]);
+}
+
+function errorResponse(err: unknown) {
+  if (err instanceof UnauthorizedError || err instanceof ForbiddenError) {
+    return NextResponse.json({ error: "Nicht berechtigt." }, { status: 403 });
+  }
+  return null;
+}
+
+const CODE_PATTERN = /^[a-z]{2,5}$/;
+
+export async function GET(request: Request) {
+  try {
+    await requireAdmin(request);
+  } catch (err) {
+    const res = errorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+
+  const languages = await listLanguages();
+  const hash = currentTemplateHash();
+
+  const items = await Promise.all(
+    languages.map(async (lang) => {
+      if (lang.is_base) {
+        return {
+          code: lang.code,
+          label: lang.label,
+          is_base: true,
+          active: lang.active,
+          percent: 100,
+          outdated: false,
+          missingCount: 0,
+        };
+      }
+      const rows = await listTranslations(lang.code);
+      const translated = Object.fromEntries(rows.map((r) => [r.key, r.value]));
+      const completeness = computeCompleteness(translated);
+      return {
+        code: lang.code,
+        label: lang.label,
+        is_base: false,
+        active: lang.active,
+        percent: completeness.percent,
+        outdated: lang.template_version !== hash,
+        missingCount: completeness.missingKeys.length,
+      };
+    })
+  );
+
+  return NextResponse.json(items);
+}
+
+export async function POST(request: Request) {
+  try {
+    await requireAdmin(request);
+  } catch (err) {
+    const res = errorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+
+  const body = await request.json().catch(() => null);
+  const code = String(body?.code ?? "").trim().toLowerCase();
+  const label = String(body?.label ?? "").trim();
+  if (!CODE_PATTERN.test(code) || !label) {
+    return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+  }
+
+  try {
+    const language = await createLanguage(code, label);
+    return NextResponse.json(language, { status: 201 });
+  } catch (err) {
+    if (err instanceof Error && /duplicate key/i.test(err.message)) {
+      return NextResponse.json({ error: "duplicate_code" }, { status: 409 });
+    }
+    throw err;
+  }
+}
@@ -0,0 +1,27 @@
+import { NextResponse } from "next/server";
+import { currentTemplate } from "@/lib/i18n/template";
+import { ForbiddenError, requireRole, UnauthorizedError } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+// Deutsche Vorlage (alle aktuellen Übersetzungsschlüssel + Text) zum
+// Download – wird von einem Übersetzer ausgefüllt und anschließend
+// über POST /api/admin/languages/[code]/import wieder hochgeladen.
+export async function GET(request: Request) {
+  try {
+    if (!isSameOrigin(request)) throw new ForbiddenError();
+    await requireRole(["admin"]);
+  } catch (err) {
+    if (err instanceof UnauthorizedError || err instanceof ForbiddenError) {
+      return NextResponse.json({ error: "Nicht berechtigt." }, { status: 403 });
+    }
+    throw err;
+  }
+
+  const template = currentTemplate();
+  return new NextResponse(JSON.stringify(template, null, 2), {
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+      "Content-Disposition": 'attachment; filename="sprachvorlage.json"',
+    },
+  });
+}
@@ -1,33 +1,48 @@
 import { NextResponse } from "next/server";
-import { createClient } from "@/lib/supabase/server";
-import { createAdminClient } from "@/lib/supabase/admin";
+import { query, queryOne } from "@/lib/db";
+import { hashPassword } from "@/lib/auth/password";
+import { requireRole, UnauthorizedError, ForbiddenError } from "@/lib/auth/session";
 import { isSameOrigin } from "@/lib/origin";
+import type { Profile } from "@/lib/types";

-// Benutzerverwaltung (nur Admin). Läuft serverseitig mit dem
-// Service-Role-Key, da das Anlegen/Löschen von Auth-Benutzern
-// nicht über den anon key möglich ist.
+// Benutzerverwaltung (nur Admin).

 async function requireAdmin(request: Request) {
-  if (!isSameOrigin(request)) return null;
-  const supabase = await createClient();
-  const {
-    data: { user },
-  } = await supabase.auth.getUser();
-  if (!user) return null;
+  if (!isSameOrigin(request)) throw new ForbiddenError();
+  return requireRole(["admin"]);
+}

-  const admin = createAdminClient();
-  const { data: profile } = await admin
-    .from("profiles")
-    .select("role")
-    .eq("id", user.id)
-    .single();
-  if (profile?.role !== "admin") return null;
-  return { user, admin };
+function errorResponse(err: unknown) {
+  if (err instanceof UnauthorizedError || err instanceof ForbiddenError) {
+    return NextResponse.json({ error: "Nicht berechtigt." }, { status: 403 });
+  }
+  return null;
+}
+
+export async function GET(request: Request) {
+  try {
+    await requireAdmin(request);
+  } catch (err) {
+    const res = errorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+  const profiles = await query<Profile>(
+    "select id, email, full_name, role, password_auth_enabled, created_at from users order by created_at"
+  );
+  return NextResponse.json(profiles);
 }

 export async function POST(request: Request) {
-  const ctx = await requireAdmin(request);
-  if (!ctx) return NextResponse.json({ error: "Nicht berechtigt." }, { status: 403 });
+  let session;
+  try {
+    session = await requireAdmin(request);
+  } catch (err) {
+    const res = errorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+  void session;

  const body = await request.json().catch(() => null);
  const { email, password, full_name, role } = body ?? {};
@@ -41,28 +56,33 @@ export async function POST(request: Request) {
    );
  }

-  const { data, error } = await ctx.admin.auth.admin.createUser({
-    email,
-    password,
-    email_confirm: true,
-    user_metadata: { full_name: full_name ?? "", role },
-  });
-  if (error) {
+  try {
+    const user = await queryOne<{ id: string }>(
+      `insert into users (email, password_hash, full_name, role)
+       values ($1, $2, $3, $4) returning id`,
+      [String(email).trim().toLowerCase(), hashPassword(password), full_name ?? "", role]
+    );
+    return NextResponse.json({ id: user?.id });
+  } catch (err) {
+    if (err instanceof Error && /unique/i.test(err.message)) {
      return NextResponse.json(
-      {
-        error: /already been registered/i.test(error.message)
-          ? "Diese E-Mail-Adresse ist bereits registriert."
-          : error.message,
-      },
+        { error: "Diese E-Mail-Adresse ist bereits registriert." },
        { status: 400 }
      );
    }
-  return NextResponse.json({ id: data.user?.id });
+    throw err;
+  }
 }

 export async function PATCH(request: Request) {
-  const ctx = await requireAdmin(request);
-  if (!ctx) return NextResponse.json({ error: "Nicht berechtigt." }, { status: 403 });
+  let session;
+  try {
+    session = await requireAdmin(request);
+  } catch (err) {
+    const res = errorResponse(err);
+    if (res) return res;
+    throw err;
+  }

  const body = await request.json().catch(() => null);
  const { id, full_name, role, password } = body ?? {};
@@ -71,7 +91,7 @@ export async function PATCH(request: Request) {
  }
  // Der Admin darf sich nicht selbst die Admin-Rolle entziehen,
  // sonst sperrt er sich aus der Verwaltung aus.
-  if (id === ctx.user.id && role === "staff") {
+  if (id === session.user.id && role === "staff") {
    return NextResponse.json(
      { error: "Du kannst dir nicht selbst die Admin-Rolle entziehen." },
      { status: 400 }
@@ -85,35 +105,49 @@ export async function PATCH(request: Request) {
        { status: 400 }
      );
    }
-    const { error } = await ctx.admin.auth.admin.updateUserById(id, { password });
-    if (error) return NextResponse.json({ error: error.message }, { status: 400 });
+    await query("update users set password_hash = $1 where id = $2", [
+      hashPassword(password),
+      id,
+    ]);
  }

-  const updates: Record<string, string> = {};
-  if (typeof full_name === "string") updates.full_name = full_name;
-  if (role) updates.role = role;
-  if (Object.keys(updates).length > 0) {
-    const { error } = await ctx.admin.from("profiles").update(updates).eq("id", id);
-    if (error) return NextResponse.json({ error: error.message }, { status: 400 });
+  const fields: string[] = [];
+  const values: unknown[] = [];
+  if (typeof full_name === "string") {
+    values.push(full_name);
+    fields.push(`full_name = $${values.length}`);
+  }
+  if (role) {
+    values.push(role);
+    fields.push(`role = $${values.length}`);
+  }
+  if (fields.length > 0) {
+    values.push(id);
+    await query(`update users set ${fields.join(", ")} where id = $${values.length}`, values);
  }
  return NextResponse.json({ ok: true });
 }

 export async function DELETE(request: Request) {
-  const ctx = await requireAdmin(request);
-  if (!ctx) return NextResponse.json({ error: "Nicht berechtigt." }, { status: 403 });
+  let session;
+  try {
+    session = await requireAdmin(request);
+  } catch (err) {
+    const res = errorResponse(err);
+    if (res) return res;
+    throw err;
+  }

  const body = await request.json().catch(() => null);
  const { id } = body ?? {};
  if (!id) return NextResponse.json({ error: "Ungültige Eingaben." }, { status: 400 });
-  if (id === ctx.user.id) {
+  if (id === session.user.id) {
    return NextResponse.json(
      { error: "Du kannst dich nicht selbst löschen." },
      { status: 400 }
    );
  }

-  const { error } = await ctx.admin.auth.admin.deleteUser(id);
-  if (error) return NextResponse.json({ error: error.message }, { status: 400 });
+  await query("delete from users where id = $1", [id]);
  return NextResponse.json({ ok: true });
 }
@@ -0,0 +1,47 @@
+import { NextResponse } from "next/server";
+import { deleteCode, updateCode } from "@/lib/db/code-lists";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function PATCH(
+  request: Request,
+  { params }: { params: Promise<{ code: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { code } = await params;
+    const body = await request.json();
+    const item = await updateCode("allergens", code, body);
+    if (!item) return NextResponse.json({ error: "not_found" }, { status: 404 });
+    return NextResponse.json(item);
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    if (err instanceof Error && /duplicate key/i.test(err.message)) {
+      return NextResponse.json({ error: "duplicate_code" }, { status: 409 });
+    }
+    throw err;
+  }
+}
+
+export async function DELETE(
+  request: Request,
+  { params }: { params: Promise<{ code: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { code } = await params;
+    await deleteCode("allergens", code);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,29 @@
+import { listCodes } from "@/lib/db/code-lists";
+import { listActiveLanguageCodes } from "@/lib/db/languages";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { toCsv } from "@/lib/csv";
+
+export async function GET() {
+  try {
+    await requireRole(["staff", "admin"]);
+    const [items, activeCodes] = await Promise.all([
+      listCodes("allergens"),
+      listActiveLanguageCodes(),
+    ]);
+    const langCodes = activeCodes.filter((c) => c !== "de");
+    const rows = [
+      ["code", "name", ...langCodes.map((c) => `name_${c}`)],
+      ...items.map((i) => [i.code, i.name, ...langCodes.map((c) => i.translations[c] ?? "")]),
+    ];
+    return new Response(toCsv(rows), {
+      headers: {
+        "Content-Type": "text/csv; charset=utf-8",
+        "Content-Disposition": 'attachment; filename="allergene.csv"',
+      },
+    });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,56 @@
+import { NextResponse } from "next/server";
+import { importCodes, type CodeImportRow } from "@/lib/db/code-lists";
+import { listActiveLanguageCodes } from "@/lib/db/languages";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+import { parseCsvWithHeader } from "@/lib/csv";
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const form = await request.formData();
+    const file = form.get("file");
+    if (!(file instanceof File)) {
+      return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+    }
+
+    const { header, rows: cells } = parseCsvWithHeader(await file.text());
+    const codeIdx = header.indexOf("code");
+    const nameIdx = header.indexOf("name");
+    if (codeIdx === -1 || nameIdx === -1) {
+      return NextResponse.json({ error: "missing_columns" }, { status: 400 });
+    }
+    const activeCodes = (await listActiveLanguageCodes()).filter((c) => c !== "de");
+    const langCols = activeCodes
+      .map((code) => ({ code, idx: header.indexOf(`name_${code}`) }))
+      .filter((c) => c.idx !== -1);
+
+    const rows: CodeImportRow[] = [];
+    const skipped: { row: number; reason: string }[] = [];
+    cells.forEach((c, i) => {
+      const rowNum = i + 2; // 1-indexiert + Kopfzeile
+      const code = (c[codeIdx] ?? "").trim();
+      const name = (c[nameIdx] ?? "").trim();
+      if (!code || !name) {
+        skipped.push({ row: rowNum, reason: "Kürzel oder Bezeichnung fehlt" });
+        return;
+      }
+      const translations: Record<string, string> = {};
+      for (const { code: lang, idx } of langCols) {
+        const value = c[idx]?.trim();
+        if (value) translations[lang] = value;
+      }
+      rows.push({ code, name, translations });
+    });
+
+    const result = rows.length > 0 ? await importCodes("allergens", rows) : { created: 0, updated: 0 };
+    return NextResponse.json({ ...result, skipped });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,27 @@
+import { NextResponse } from "next/server";
+import { createCode, listCodes } from "@/lib/db/code-lists";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function GET() {
+  return NextResponse.json(await listCodes("allergens"));
+}
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const body = await request.json();
+    const item = await createCode("allergens", body);
+    return NextResponse.json(item, { status: 201 });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    if (err instanceof Error && /duplicate key/i.test(err.message)) {
+      return NextResponse.json({ error: "duplicate_code" }, { status: 409 });
+    }
+    throw err;
+  }
+}
@@ -0,0 +1,40 @@
+import { NextResponse } from "next/server";
+import { queryOne } from "@/lib/db";
+import { verifyPassword } from "@/lib/auth/password";
+import { createSession } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+import type { Role } from "@/lib/types";
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+
+  const { email, password } = (await request.json().catch(() => ({}))) as {
+    email?: string;
+    password?: string;
+  };
+  if (!email || !password) {
+    return NextResponse.json({ error: "invalid_credentials" }, { status: 400 });
+  }
+
+  const user = await queryOne<{
+    id: string;
+    password_hash: string;
+    role: Role;
+    password_auth_enabled: boolean;
+  }>(
+    "select id, password_hash, role, password_auth_enabled from users where email = $1",
+    [email.trim().toLowerCase()]
+  );
+
+  if (!user || !verifyPassword(password, user.password_hash)) {
+    return NextResponse.json({ error: "invalid_credentials" }, { status: 401 });
+  }
+  if (!user.password_auth_enabled) {
+    return NextResponse.json({ error: "password_disabled" }, { status: 403 });
+  }
+
+  await createSession(user.id);
+  return NextResponse.json({ role: user.role });
+}
@@ -0,0 +1,60 @@
+import { NextResponse } from "next/server";
+import { queryOne } from "@/lib/db";
+import { createSession } from "@/lib/auth/session";
+import { isConfigured } from "@/lib/auth/oidc-config";
+import { consumeState } from "@/lib/auth/oidc-state";
+import { discover, exchangeCode, resolveEmail, verifyIdToken } from "@/lib/auth/oidc-client";
+import type { Role } from "@/lib/types";
+
+function errorRedirect(request: Request, code: string): NextResponse {
+  return NextResponse.redirect(new URL(`/login?error=${code}`, request.url));
+}
+
+// GET statt POST: der Identity Provider leitet den Browser per
+// Redirect hierher (Cross-Origin-Navigation) – die übliche
+// isSameOrigin()-CSRF-Prüfung greift hier nicht und wird bewusst nicht
+// verwendet. Die Absicherung ist der einmalig verwendbare state-
+// Parameter (Standard-OIDC-Mechanismus, siehe lib/auth/oidc-state.ts).
+export async function GET(request: Request) {
+  if (!isConfigured()) {
+    return errorRedirect(request, "oidc_failed");
+  }
+
+  const url = new URL(request.url);
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  const idpError = url.searchParams.get("error");
+  if (idpError || !code || !state) {
+    return errorRedirect(request, "oidc_failed");
+  }
+
+  const stored = await consumeState(state);
+  if (!stored) {
+    return errorRedirect(request, "oidc_invalid_state");
+  }
+
+  try {
+    const discovery = await discover();
+    const { idToken, accessToken } = await exchangeCode(discovery, code, stored.codeVerifier);
+    const payload = await verifyIdToken(discovery, idToken, stored.nonce);
+    const email = await resolveEmail(discovery, payload, accessToken);
+    if (!email) {
+      return errorRedirect(request, "oidc_failed");
+    }
+
+    const user = await queryOne<{ id: string; role: Role }>(
+      "select id, role from users where email = $1",
+      [email.trim().toLowerCase()]
+    );
+    if (!user) {
+      return errorRedirect(request, "oidc_unknown_user");
+    }
+
+    await createSession(user.id);
+    return NextResponse.redirect(
+      new URL(user.role === "admin" ? "/admin" : "/intern", request.url)
+    );
+  } catch {
+    return errorRedirect(request, "oidc_failed");
+  }
+}
@@ -0,0 +1,31 @@
+import { createHash, randomBytes } from "node:crypto";
+import { NextResponse } from "next/server";
+import { isConfigured } from "@/lib/auth/oidc-config";
+import { storeState } from "@/lib/auth/oidc-state";
+import { buildAuthorizeUrl, discover } from "@/lib/auth/oidc-client";
+
+// Bewusst ein einfacher GET-Link statt eines CSRF-gesicherten POSTs:
+// der Browser muss hier auf die fremde Login-Seite des Identity
+// Providers navigieren (funktioniert nicht per fetch/XHR) – identisch
+// zum Muster jeder "Login mit X"-Schaltfläche. Die Absicherung gegen
+// Cross-Site-Missbrauch übernimmt der state-Parameter im Callback.
+export async function GET(request: Request) {
+  if (!isConfigured()) {
+    return NextResponse.json({ error: "oidc_not_configured" }, { status: 404 });
+  }
+
+  const state = randomBytes(32).toString("base64url");
+  const nonce = randomBytes(32).toString("base64url");
+  const codeVerifier = randomBytes(32).toString("base64url");
+  const codeChallenge = createHash("sha256").update(codeVerifier).digest("base64url");
+
+  try {
+    const discovery = await discover();
+    await storeState(state, nonce, codeVerifier);
+    return NextResponse.redirect(
+      buildAuthorizeUrl(discovery, { state, nonce, codeChallenge })
+    );
+  } catch {
+    return NextResponse.redirect(new URL("/login?error=oidc_failed", request.url));
+  }
+}
@@ -0,0 +1,29 @@
+import { NextResponse } from "next/server";
+import { query } from "@/lib/db";
+import { requireSession, UnauthorizedError } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function DELETE(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    const session = await requireSession();
+    const { id } = await params;
+    // user_id-Filter stellt sicher, dass nur eigene Credentials gelöscht
+    // werden können.
+    await query("delete from passkey_credentials where id = $1 and user_id = $2", [
+      id,
+      session.user.id,
+    ]);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    if (err instanceof UnauthorizedError) {
+      return NextResponse.json({ error: "unauthorized" }, { status: 401 });
+    }
+    throw err;
+  }
+}
@@ -0,0 +1,16 @@
+import { NextResponse } from "next/server";
+import { generateAuthenticationOptions } from "@simplewebauthn/server";
+import { rpID } from "@/lib/auth/webauthn-config";
+import { storeChallenge } from "@/lib/auth/webauthn-challenges";
+
+// Passwortloser "usernameless"-Login: kein allowCredentials, der Browser
+// fragt den Nutzer, welchen registrierten Passkey er verwenden möchte.
+// user_id ist beim Speichern der Challenge noch unbekannt.
+export async function POST() {
+  const options = await generateAuthenticationOptions({
+    rpID: rpID(),
+    userVerification: "preferred",
+  });
+  await storeChallenge(options.challenge, "authentication", null);
+  return NextResponse.json(options);
+}
@@ -0,0 +1,75 @@
+import { NextResponse } from "next/server";
+import { verifyAuthenticationResponse } from "@simplewebauthn/server";
+import type {
+  AuthenticationResponseJSON,
+  AuthenticatorTransportFuture,
+} from "@simplewebauthn/server";
+import { query, queryOne } from "@/lib/db";
+import { createSession } from "@/lib/auth/session";
+import { origin, rpID } from "@/lib/auth/webauthn-config";
+import { consumeChallenge } from "@/lib/auth/webauthn-challenges";
+import { isSameOrigin } from "@/lib/origin";
+import type { Role } from "@/lib/types";
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+
+  const body = (await request.json()) as { response: AuthenticationResponseJSON };
+  const challenge = extractChallengeFromClientData(body.response);
+  const pending = await consumeChallenge(challenge, "authentication");
+  if (!pending) {
+    return NextResponse.json({ error: "challenge_expired" }, { status: 400 });
+  }
+
+  // Passkey-Login ist unabhängig von password_auth_enabled – dieses Flag
+  // betrifft ausschließlich den Passwort-Login.
+  const stored = await queryOne<{
+    user_id: string;
+    public_key: Buffer;
+    counter: string;
+    transports: AuthenticatorTransportFuture[];
+    role: Role;
+  }>(
+    `select pc.user_id, pc.public_key, pc.counter, pc.transports, u.role
+     from passkey_credentials pc join users u on u.id = pc.user_id
+     where pc.credential_id = $1`,
+    [body.response.id]
+  );
+  if (!stored) {
+    return NextResponse.json({ error: "unknown_credential" }, { status: 400 });
+  }
+
+  const verification = await verifyAuthenticationResponse({
+    response: body.response,
+    expectedChallenge: challenge,
+    expectedOrigin: origin(),
+    expectedRPID: rpID(),
+    credential: {
+      id: body.response.id,
+      publicKey: new Uint8Array(stored.public_key),
+      counter: Number(stored.counter),
+      transports: stored.transports,
+    },
+  });
+
+  if (!verification.verified) {
+    return NextResponse.json({ error: "verification_failed" }, { status: 400 });
+  }
+
+  await query(
+    "update passkey_credentials set counter = $1, last_used_at = now() where credential_id = $2",
+    [verification.authenticationInfo.newCounter, body.response.id]
+  );
+
+  await createSession(stored.user_id);
+  return NextResponse.json({ role: stored.role });
+}
+
+function extractChallengeFromClientData(response: AuthenticationResponseJSON): string {
+  const json = JSON.parse(
+    Buffer.from(response.response.clientDataJSON, "base64url").toString("utf8")
+  ) as { challenge: string };
+  return json.challenge;
+}
@@ -0,0 +1,45 @@
+import { NextResponse } from "next/server";
+import { generateRegistrationOptions } from "@simplewebauthn/server";
+import type { AuthenticatorTransportFuture } from "@simplewebauthn/server";
+import { query } from "@/lib/db";
+import { requireSession, UnauthorizedError } from "@/lib/auth/session";
+import { rpID, rpName } from "@/lib/auth/webauthn-config";
+import { storeChallenge } from "@/lib/auth/webauthn-challenges";
+
+export async function POST() {
+  try {
+    const session = await requireSession();
+
+    const existing = await query<{
+      credential_id: string;
+      transports: AuthenticatorTransportFuture[];
+    }>("select credential_id, transports from passkey_credentials where user_id = $1", [
+      session.user.id,
+    ]);
+
+    const options = await generateRegistrationOptions({
+      rpName: rpName(),
+      rpID: rpID(),
+      userID: new TextEncoder().encode(session.user.id),
+      userName: session.user.email,
+      userDisplayName: session.user.full_name || session.user.email,
+      attestationType: "none",
+      excludeCredentials: existing.map((c) => ({
+        id: c.credential_id,
+        transports: c.transports,
+      })),
+      authenticatorSelection: {
+        residentKey: "preferred",
+        userVerification: "preferred",
+      },
+    });
+
+    await storeChallenge(options.challenge, "registration", session.user.id);
+    return NextResponse.json(options);
+  } catch (err) {
+    if (err instanceof UnauthorizedError) {
+      return NextResponse.json({ error: "unauthorized" }, { status: 401 });
+    }
+    throw err;
+  }
+}
@@ -0,0 +1,69 @@
+import { NextResponse } from "next/server";
+import { verifyRegistrationResponse } from "@simplewebauthn/server";
+import type { RegistrationResponseJSON } from "@simplewebauthn/server";
+import { query } from "@/lib/db";
+import { requireSession, UnauthorizedError } from "@/lib/auth/session";
+import { origin, rpID } from "@/lib/auth/webauthn-config";
+import { consumeChallenge } from "@/lib/auth/webauthn-challenges";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    const session = await requireSession();
+    const body = (await request.json()) as {
+      response: RegistrationResponseJSON;
+      name?: string;
+    };
+
+    const challenge = extractChallengeFromClientData(body.response);
+    const pending = await consumeChallenge(challenge, "registration");
+    if (!pending || pending.userId !== session.user.id) {
+      return NextResponse.json({ error: "challenge_expired" }, { status: 400 });
+    }
+
+    const verification = await verifyRegistrationResponse({
+      response: body.response,
+      expectedChallenge: challenge,
+      expectedOrigin: origin(),
+      expectedRPID: rpID(),
+    });
+
+    if (!verification.verified || !verification.registrationInfo) {
+      return NextResponse.json({ error: "verification_failed" }, { status: 400 });
+    }
+
+    const { credential } = verification.registrationInfo;
+    await query(
+      `insert into passkey_credentials (user_id, credential_id, public_key, counter, transports, name)
+       values ($1, $2, $3, $4, $5, $6)`,
+      [
+        session.user.id,
+        credential.id,
+        Buffer.from(credential.publicKey),
+        credential.counter,
+        credential.transports ?? [],
+        body.name ?? null,
+      ]
+    );
+
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    if (err instanceof UnauthorizedError) {
+      return NextResponse.json({ error: "unauthorized" }, { status: 401 });
+    }
+    throw err;
+  }
+}
+
+// clientDataJSON ist base64url-kodiertes JSON mit dem Feld "challenge" –
+// darüber wird die zugehörige, serverseitig gespeicherte Challenge
+// gefunden, ohne sie zusätzlich im Request-Body mitschicken zu müssen.
+function extractChallengeFromClientData(response: RegistrationResponseJSON): string {
+  const json = JSON.parse(
+    Buffer.from(response.response.clientDataJSON, "base64url").toString("utf8")
+  ) as { challenge: string };
+  return json.challenge;
+}
@@ -0,0 +1,25 @@
+import { NextResponse } from "next/server";
+import { query } from "@/lib/db";
+import { requireSession, UnauthorizedError } from "@/lib/auth/session";
+
+export async function GET() {
+  try {
+    const session = await requireSession();
+    const rows = await query<{
+      id: string;
+      name: string | null;
+      created_at: string;
+      last_used_at: string | null;
+    }>(
+      `select id, name, created_at, last_used_at from passkey_credentials
+       where user_id = $1 order by created_at`,
+      [session.user.id]
+    );
+    return NextResponse.json(rows);
+  } catch (err) {
+    if (err instanceof UnauthorizedError) {
+      return NextResponse.json({ error: "unauthorized" }, { status: 401 });
+    }
+    throw err;
+  }
+}
@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { removeClosedDay } from "@/lib/db/closed-days";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function DELETE(
+  request: Request,
+  { params }: { params: Promise<{ date: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { date } = await params;
+    await removeClosedDay(date);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,34 @@
+import { NextResponse } from "next/server";
+import { listClosedDays, setClosedDay } from "@/lib/db/closed-days";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const from = searchParams.get("from");
+  const to = searchParams.get("to");
+  if (!from || !to) {
+    return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+  }
+  return NextResponse.json(await listClosedDays(from, to));
+}
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const body = (await request.json()) as {
+      closed_date: string;
+      reason: string | null;
+      translations?: Record<string, string | null>;
+    };
+    const closedDay = await setClosedDay(body.closed_date, body.reason, body.translations);
+    return NextResponse.json(closedDay, { status: 201 });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,37 @@
+import { NextResponse } from "next/server";
+import { withTransaction } from "@/lib/db";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { id } = await params;
+
+    const created = await withTransaction(async (client) => {
+      const suggestion = await client.query<{ name: string }>(
+        "select name from dish_suggestions where id = $1",
+        [id]
+      );
+      if (suggestion.rows.length === 0) return null;
+      await client.query("insert into dishes (name, price) values ($1, 0)", [
+        suggestion.rows[0].name,
+      ]);
+      await client.query("delete from dish_suggestions where id = $1", [id]);
+      return true;
+    });
+
+    if (!created) return NextResponse.json({ error: "not_found" }, { status: 404 });
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { query } from "@/lib/db";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function DELETE(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { id } = await params;
+    await query("delete from dish_suggestions where id = $1", [id]);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,45 @@
+import { NextResponse } from "next/server";
+import { query, queryOne } from "@/lib/db";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+import type { DishSuggestion } from "@/lib/types";
+
+export async function GET() {
+  try {
+    await requireRole(["staff", "admin"]);
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+  const items = await query<DishSuggestion>(
+    "select * from dish_suggestions order by created_at desc"
+  );
+  return NextResponse.json(items);
+}
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  const body = (await request.json().catch(() => ({}))) as {
+    name?: string;
+    description?: string;
+  };
+  const name = body.name?.trim();
+  if (!name) return NextResponse.json({ error: "name_required" }, { status: 400 });
+
+  // Serverseitig statt clientseitig (wie zuvor über den anon-Postgrest-
+  // Zugriff): es gibt keinen Browser→Postgres-Pfad mehr.
+  const existing = await queryOne<{ id: string }>(
+    "select id from dishes where name ilike $1 limit 1",
+    [name]
+  );
+  if (existing) return NextResponse.json({ error: "duplicate" }, { status: 409 });
+
+  await query("insert into dish_suggestions (name, description) values ($1, $2)", [
+    name,
+    body.description?.trim() || null,
+  ]);
+  return NextResponse.json({ ok: true }, { status: 201 });
+}
@@ -0,0 +1,73 @@
+import { NextResponse } from "next/server";
+import { query, queryOne } from "@/lib/db";
+import { loadTranslationsFor, replaceTranslations } from "@/lib/db/translations";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+import type { Dish } from "@/lib/types";
+
+interface DishRow {
+  id: string;
+  name: string;
+  price: string;
+  allergens: string[];
+  additives: string[];
+}
+
+export async function PATCH(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { id } = await params;
+    const body = (await request.json()) as {
+      name: string;
+      price: number;
+      allergens: string[];
+      additives: string[];
+      translations?: Record<string, string | null>;
+    };
+    const row = await queryOne<DishRow>(
+      `update dishes set name = $1, price = $2, allergens = $3, additives = $4
+       where id = $5 returning id, name, price, allergens, additives`,
+      [body.name, body.price, body.allergens, body.additives, id]
+    );
+    if (!row) return NextResponse.json({ error: "not_found" }, { status: 404 });
+    if (body.translations) {
+      await replaceTranslations("dish_translations", row.id, body.translations);
+    }
+    const translations = await loadTranslationsFor("dish_translations", [row.id]);
+    const dish: Dish = {
+      ...row,
+      price: Number(row.price),
+      translations: translations.get(row.id) ?? {},
+    };
+    return NextResponse.json(dish);
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
+
+export async function DELETE(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { id } = await params;
+    await query("delete from dishes where id = $1", [id]);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { query } from "@/lib/db";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { ids } = (await request.json()) as { ids: string[] };
+    if (!Array.isArray(ids) || ids.length === 0) {
+      return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+    }
+    await query("delete from dishes where id = any($1::uuid[])", [ids]);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,48 @@
+import { query } from "@/lib/db";
+import { loadTranslationsFor } from "@/lib/db/translations";
+import { listActiveLanguageCodes } from "@/lib/db/languages";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { toCsv } from "@/lib/csv";
+
+interface DishRow {
+  id: string;
+  name: string;
+  price: string;
+  allergens: string[];
+  additives: string[];
+}
+
+export async function GET() {
+  try {
+    await requireRole(["staff", "admin"]);
+    const [dishes, activeCodes] = await Promise.all([
+      query<DishRow>("select id, name, price, allergens, additives from dishes order by name"),
+      listActiveLanguageCodes(),
+    ]);
+    const langCodes = activeCodes.filter((c) => c !== "de");
+    const translations = await loadTranslationsFor(
+      "dish_translations",
+      dishes.map((d) => d.id)
+    );
+    const rows = [
+      ["name", ...langCodes.map((c) => `name_${c}`), "price", "allergens", "additives"],
+      ...dishes.map((d) => [
+        d.name,
+        ...langCodes.map((c) => translations.get(d.id)?.[c] ?? ""),
+        d.price,
+        (d.allergens ?? []).join(";"),
+        (d.additives ?? []).join(";"),
+      ]),
+    ];
+    return new Response(toCsv(rows), {
+      headers: {
+        "Content-Type": "text/csv; charset=utf-8",
+        "Content-Disposition": 'attachment; filename="gerichte.csv"',
+      },
+    });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,124 @@
+import { NextResponse } from "next/server";
+import { withTransaction } from "@/lib/db";
+import { replaceTranslations } from "@/lib/db/translations";
+import { listActiveLanguageCodes } from "@/lib/db/languages";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+import { parseCsvWithHeader, splitCodes } from "@/lib/csv";
+
+interface ImportRow {
+  rowNum: number;
+  name: string;
+  translations: Record<string, string>;
+  price: number;
+  allergens: string[];
+  additives: string[];
+}
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const form = await request.formData();
+    const file = form.get("file");
+    if (!(file instanceof File)) {
+      return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+    }
+
+    const { header, rows: cells } = parseCsvWithHeader(await file.text());
+    const nameIdx = header.indexOf("name");
+    const priceIdx = header.indexOf("price");
+    if (nameIdx === -1 || priceIdx === -1) {
+      return NextResponse.json({ error: "missing_columns" }, { status: 400 });
+    }
+    const activeCodes = (await listActiveLanguageCodes()).filter((c) => c !== "de");
+    const langCols = activeCodes
+      .map((code) => ({ code, idx: header.indexOf(`name_${code}`) }))
+      .filter((c) => c.idx !== -1);
+    const allergensIdx = header.indexOf("allergens");
+    const additivesIdx = header.indexOf("additives");
+
+    const rows: ImportRow[] = [];
+    const skipped: { row: number; reason: string }[] = [];
+    cells.forEach((c, i) => {
+      const rowNum = i + 2; // 1-indexiert + Kopfzeile
+      const name = (c[nameIdx] ?? "").trim();
+      if (!name) {
+        skipped.push({ row: rowNum, reason: "Name fehlt" });
+        return;
+      }
+      const priceRaw = (c[priceIdx] ?? "").trim().replace(",", ".");
+      const price = Number.parseFloat(priceRaw);
+      if (Number.isNaN(price) || price < 0) {
+        skipped.push({ row: rowNum, reason: `Ungültiger Preis „${c[priceIdx] ?? ""}“` });
+        return;
+      }
+      const translations: Record<string, string> = {};
+      for (const { code, idx } of langCols) {
+        const value = c[idx]?.trim();
+        if (value) translations[code] = value;
+      }
+      rows.push({
+        rowNum,
+        name,
+        translations,
+        price,
+        allergens: allergensIdx >= 0 ? splitCodes(c[allergensIdx]) : [],
+        additives: additivesIdx >= 0 ? splitCodes(c[additivesIdx]) : [],
+      });
+    });
+
+    let created = 0;
+    let updated = 0;
+    const savedTranslations: { id: string; translations: Record<string, string> }[] = [];
+    if (rows.length > 0) {
+      await withTransaction(async (client) => {
+        for (const row of rows) {
+          // Gerichtsnamen sind nicht eindeutig (keine DB-Constraint) – bei
+          // mehreren Treffern lieber überspringen als versehentlich alle
+          // gleichnamigen Gerichte mit denselben Werten zu überschreiben.
+          const existing = await client.query<{ id: string }>(
+            "select id from dishes where name = $1",
+            [row.name]
+          );
+          if (existing.rows.length > 1) {
+            skipped.push({
+              row: row.rowNum,
+              reason: `„${row.name}“ ist mehrdeutig (mehrere Gerichte mit diesem Namen) – übersprungen`,
+            });
+            continue;
+          }
+          if (existing.rows.length === 1) {
+            await client.query(
+              `update dishes set price = $1, allergens = $2, additives = $3 where id = $4`,
+              [row.price, row.allergens, row.additives, existing.rows[0].id]
+            );
+            savedTranslations.push({ id: existing.rows[0].id, translations: row.translations });
+            updated++;
+          } else {
+            const inserted = await client.query<{ id: string }>(
+              `insert into dishes (name, price, allergens, additives)
+               values ($1, $2, $3, $4) returning id`,
+              [row.name, row.price, row.allergens, row.additives]
+            );
+            savedTranslations.push({ id: inserted.rows[0].id, translations: row.translations });
+            created++;
+          }
+        }
+      });
+      for (const { id, translations } of savedTranslations) {
+        if (Object.keys(translations).length > 0) {
+          await replaceTranslations("dish_translations", id, translations);
+        }
+      }
+    }
+
+    return NextResponse.json({ created, updated, skipped });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,63 @@
+import { NextResponse } from "next/server";
+import { query, queryOne } from "@/lib/db";
+import { loadTranslationsFor, replaceTranslations } from "@/lib/db/translations";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+import type { Dish } from "@/lib/types";
+
+interface DishRow {
+  id: string;
+  name: string;
+  price: string;
+  allergens: string[];
+  additives: string[];
+}
+
+async function withTranslations(rows: DishRow[]): Promise<Dish[]> {
+  const translations = await loadTranslationsFor(
+    "dish_translations",
+    rows.map((r) => r.id)
+  );
+  return rows.map((r) => ({
+    ...r,
+    price: Number(r.price),
+    translations: translations.get(r.id) ?? {},
+  }));
+}
+
+export async function GET() {
+  const rows = await query<DishRow>(
+    "select id, name, price, allergens, additives from dishes order by name"
+  );
+  return NextResponse.json(await withTranslations(rows));
+}
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const body = (await request.json()) as {
+      name: string;
+      price: number;
+      allergens: string[];
+      additives: string[];
+      translations?: Record<string, string | null>;
+    };
+    const row = (await queryOne<DishRow>(
+      `insert into dishes (name, price, allergens, additives)
+       values ($1, $2, $3, $4) returning id, name, price, allergens, additives`,
+      [body.name, body.price, body.allergens, body.additives]
+    ))!;
+    if (body.translations) {
+      await replaceTranslations("dish_translations", row.id, body.translations);
+    }
+    const [dish] = await withTranslations([row]);
+    return NextResponse.json(dish, { status: 201 });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,25 @@
+import { NextResponse } from "next/server";
+import { isLocale, LOCALE_COOKIE } from "@/lib/i18n";
+import { listActiveLanguageCodes } from "@/lib/db/languages";
+import { isSameOrigin } from "@/lib/origin";
+
+// Setzt das Sprach-Cookie. Kein Login nötig (auch anonyme Besucher
+// der öffentlichen Speisekarte sollen die Sprache wechseln können).
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  const body = await request.json().catch(() => null);
+  const locale = body?.locale;
+  const active = await listActiveLanguageCodes();
+  if (!isLocale(locale, active)) {
+    return NextResponse.json({ error: "Ungültige Sprache." }, { status: 400 });
+  }
+  const response = NextResponse.json({ ok: true });
+  response.cookies.set(LOCALE_COOKIE, locale, {
+    path: "/",
+    maxAge: 60 * 60 * 24 * 365,
+    sameSite: "lax",
+  });
+  return response;
+}
@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { query } from "@/lib/db";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function DELETE(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { id } = await params;
+    await query("delete from menu_entries where id = $1", [id]);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,41 @@
+import { NextResponse } from "next/server";
+import { queryOne } from "@/lib/db";
+import { loadMenuEntries } from "@/lib/db/menu-entries";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const from = searchParams.get("from");
+  const to = searchParams.get("to");
+  if (!from || !to) {
+    return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+  }
+  return NextResponse.json(await loadMenuEntries(from, to));
+}
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const body = (await request.json()) as {
+      menu_date: string;
+      section_key: string;
+      dish_id: string;
+    };
+    const entry = await queryOne<{ id: string }>(
+      "insert into menu_entries (menu_date, section_key, dish_id) values ($1, $2, $3) returning id",
+      [body.menu_date, body.section_key, body.dish_id]
+    );
+    return NextResponse.json(entry, { status: 201 });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    if (err instanceof Error && /duplicate key/i.test(err.message)) {
+      return NextResponse.json({ error: "duplicate_entry" }, { status: 409 });
+    }
+    throw err;
+  }
+}
@@ -0,0 +1,82 @@
+import { NextResponse } from "next/server";
+import { query, queryOne } from "@/lib/db";
+import { loadTranslationsFor, replaceTranslations } from "@/lib/db/translations";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+import type { Section } from "@/lib/types";
+
+interface SectionRow {
+  key: string;
+  label: string;
+  time_range: string;
+  sort: number;
+}
+
+export async function PATCH(
+  request: Request,
+  { params }: { params: Promise<{ key: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { key } = await params;
+    const body = (await request.json()) as Partial<
+      Pick<Section, "label" | "time_range" | "sort">
+    > & { translations?: Record<string, string | null> };
+
+    const fields: string[] = [];
+    const values: unknown[] = [];
+    for (const col of ["label", "time_range", "sort"] as const) {
+      if (body[col] !== undefined) {
+        values.push(body[col]);
+        fields.push(`${col} = $${values.length}`);
+      }
+    }
+    let row: SectionRow | null;
+    if (fields.length > 0) {
+      values.push(key);
+      row = await queryOne<SectionRow>(
+        `update sections set ${fields.join(", ")} where key = $${values.length}
+         returning key, label, time_range, sort`,
+        values
+      );
+    } else {
+      row = await queryOne<SectionRow>(
+        "select key, label, time_range, sort from sections where key = $1",
+        [key]
+      );
+    }
+    if (!row) return NextResponse.json({ error: "not_found" }, { status: 404 });
+    if (body.translations) {
+      await replaceTranslations("section_translations", row.key, body.translations);
+    }
+    const translations = await loadTranslationsFor("section_translations", [row.key]);
+    const section: Section = { ...row, translations: translations.get(row.key) ?? {} };
+    return NextResponse.json(section);
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
+
+export async function DELETE(
+  request: Request,
+  { params }: { params: Promise<{ key: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { key } = await params;
+    await query("delete from sections where key = $1", [key]);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,60 @@
+import { NextResponse } from "next/server";
+import { query, queryOne } from "@/lib/db";
+import { loadTranslationsFor, replaceTranslations } from "@/lib/db/translations";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+import type { Section } from "@/lib/types";
+
+interface SectionRow {
+  key: string;
+  label: string;
+  time_range: string;
+  sort: number;
+}
+
+async function withTranslations(rows: SectionRow[]): Promise<Section[]> {
+  const translations = await loadTranslationsFor(
+    "section_translations",
+    rows.map((r) => r.key)
+  );
+  return rows.map((r) => ({ ...r, translations: translations.get(r.key) ?? {} }));
+}
+
+export async function GET() {
+  const rows = await query<SectionRow>(
+    "select key, label, time_range, sort from sections order by sort"
+  );
+  return NextResponse.json(await withTranslations(rows));
+}
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const body = (await request.json()) as {
+      label: string;
+      time_range: string;
+      translations?: Record<string, string | null>;
+    };
+
+    const maxRow = await queryOne<{ sort: number }>(
+      "select sort from sections order by sort desc limit 1"
+    );
+    const row = (await queryOne<SectionRow>(
+      `insert into sections (label, time_range, sort)
+       values ($1, $2, $3) returning key, label, time_range, sort`,
+      [body.label, body.time_range, (maxRow?.sort ?? 0) + 1]
+    ))!;
+    if (body.translations) {
+      await replaceTranslations("section_translations", row.key, body.translations);
+    }
+    const [section] = await withTranslations([row]);
+    return NextResponse.json(section, { status: 201 });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,69 @@
+import { NextResponse } from "next/server";
+import { query } from "@/lib/db";
+import { getSettings, type LabelingMode } from "@/lib/db/settings";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function GET() {
+  return NextResponse.json(await getSettings());
+}
+
+interface SettingsPatchBody {
+  colors?: Record<string, string>;
+  labeling_mode?: LabelingMode;
+  labeling_notice?: string;
+  labeling_notice_en?: string | null;
+  labeling_notice_pl?: string | null;
+}
+
+export async function PATCH(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    // Farben bleiben admin-only wie bisher; die Allergen-/Zusatzstoff-
+    // Anzeige darf auch Kantinenpersonal umschalten/bearbeiten.
+    const session = await requireRole(["staff", "admin"]);
+    const body = (await request.json()) as SettingsPatchBody;
+
+    const sets: string[] = [];
+    const params: unknown[] = [];
+
+    if (body.colors !== undefined) {
+      if (session.user.role !== "admin") {
+        return NextResponse.json({ error: "forbidden" }, { status: 403 });
+      }
+      params.push(JSON.stringify(body.colors));
+      sets.push(`colors = $${params.length}`);
+    }
+    if (body.labeling_mode !== undefined) {
+      if (body.labeling_mode !== "detailed" && body.labeling_mode !== "notice") {
+        return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+      }
+      params.push(body.labeling_mode);
+      sets.push(`labeling_mode = $${params.length}`);
+    }
+    if (body.labeling_notice !== undefined) {
+      params.push(body.labeling_notice);
+      sets.push(`labeling_notice = $${params.length}`);
+    }
+    if (body.labeling_notice_en !== undefined) {
+      params.push(body.labeling_notice_en);
+      sets.push(`labeling_notice_en = $${params.length}`);
+    }
+    if (body.labeling_notice_pl !== undefined) {
+      params.push(body.labeling_notice_pl);
+      sets.push(`labeling_notice_pl = $${params.length}`);
+    }
+
+    if (sets.length === 0) {
+      return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+    }
+    await query(`update settings set ${sets.join(", ")} where id = 1`, params);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,116 @@
+import { NextResponse } from "next/server";
+import { listActiveLanguageCodes } from "@/lib/db/languages";
+import { replaceTranslations, type TranslationTable } from "@/lib/db/translations";
+import { requireRole, UnauthorizedError, ForbiddenError } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+// Übersetzt einen deutschen Text via DeepL in alle aktiven, von DeepL
+// unterstützten Sprachen und schreibt das Ergebnis in die passende
+// *_translations-Tabelle. Ohne DEEPL_API_KEY läuft die Route kontrolliert
+// ins Leere (configured: false), damit das UI die manuelle Eingabe anbietet.
+
+const ALLOWED_TABLES: Record<string, { idColumn: string; translationTable: TranslationTable }> = {
+  dishes: { idColumn: "id", translationTable: "dish_translations" },
+  sections: { idColumn: "key", translationTable: "section_translations" },
+  allergens: { idColumn: "code", translationTable: "allergen_translations" },
+  additives: { idColumn: "code", translationTable: "additive_translations" },
+  closed_days: { idColumn: "closed_date", translationTable: "closed_day_translations" },
+};
+
+// Unsere Sprachcodes -> DeepL target_lang. Sprachen ohne Eintrag hier sind
+// von DeepL nicht unterstützt und bleiben bei manueller Eingabe.
+const DEEPL_TARGET_LANG: Record<string, string> = {
+  en: "EN", pl: "PL", fr: "FR", es: "ES", it: "IT", nl: "NL", pt: "PT-PT",
+  ru: "RU", ja: "JA", zh: "ZH", cs: "CS", da: "DA", el: "EL", fi: "FI",
+  hu: "HU", id: "ID", ko: "KO", nb: "NB", ro: "RO", sk: "SK", sl: "SL",
+  sv: "SV", tr: "TR", uk: "UK", bg: "BG", et: "ET", lv: "LV", lt: "LT",
+};
+
+async function translateWithDeepL(text: string, targetLang: string, apiKey: string) {
+  const host = apiKey.endsWith(":fx")
+    ? "https://api-free.deepl.com"
+    : "https://api.deepl.com";
+  const res = await fetch(`${host}/v2/translate`, {
+    method: "POST",
+    headers: {
+      Authorization: `DeepL-Auth-Key ${apiKey}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      text: [text],
+      target_lang: targetLang,
+      source_lang: "DE",
+    }),
+  });
+  if (!res.ok) {
+    throw new Error(`DeepL antwortete mit ${res.status}: ${await res.text()}`);
+  }
+  const data = await res.json();
+  return data.translations?.[0]?.text as string | undefined;
+}
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+
+  try {
+    await requireRole(["staff", "admin"]);
+  } catch (err) {
+    if (err instanceof UnauthorizedError) {
+      return NextResponse.json({ error: "Nicht angemeldet." }, { status: 401 });
+    }
+    if (err instanceof ForbiddenError) {
+      return NextResponse.json({ error: "Nicht berechtigt." }, { status: 403 });
+    }
+    throw err;
+  }
+
+  const body = await request.json().catch(() => null);
+  const { table, id, text } = body ?? {};
+  const config = ALLOWED_TABLES[table];
+  if (!config || typeof text !== "string" || !text.trim()) {
+    return NextResponse.json({ error: "Ungültige Eingaben." }, { status: 400 });
+  }
+  // Bei einem noch nicht gespeicherten (neuen) Eintrag gibt es keine
+  // Zeile zum Aktualisieren – nur übersetzen, das Speichern übernimmt
+  // anschließend das reguläre Formular.
+  const persist = typeof id === "string" && id.length > 0;
+
+  const apiKey = process.env.DEEPL_API_KEY;
+  if (!apiKey) {
+    return NextResponse.json({ configured: false });
+  }
+
+  const activeCodes = (await listActiveLanguageCodes()).filter((c) => c !== "de");
+  const targets = activeCodes
+    .map((code) => ({ code, target: DEEPL_TARGET_LANG[code.toLowerCase()] }))
+    .filter((t): t is { code: string; target: string } => Boolean(t.target));
+
+  try {
+    const results = await Promise.all(
+      targets.map(async (t) => ({
+        code: t.code,
+        text: await translateWithDeepL(text, t.target, apiKey),
+      }))
+    );
+    const translations: Record<string, string> = {};
+    for (const r of results) {
+      if (r.text) translations[r.code] = r.text;
+    }
+    if (Object.keys(translations).length === 0) {
+      throw new Error("Keine Übersetzung erhalten.");
+    }
+
+    if (persist) {
+      await replaceTranslations(config.translationTable, id, translations);
+    }
+
+    return NextResponse.json({ configured: true, translations });
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Übersetzung fehlgeschlagen." },
+      { status: 502 }
+    );
+  }
+}
@@ -0,0 +1,36 @@
+import { readBrandingFile } from "@/lib/branding";
+
+// Kein svg: würde mit Content-Type image/svg+xml ausgeliefert und ist
+// bei direkter Navigation auf die Datei aktiv ausführbar (eingebettetes
+// <script> läuft dann same-origin inkl. Session-Cookie) – anders als bei
+// Einbettung per <img>/<link rel="icon">. Nur ungefährliche Rasterformate
+// zulassen, siehe auch die Whitelist beim Upload in api/admin/branding.
+const CONTENT_TYPES: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  ico: "image/x-icon",
+  gif: "image/gif",
+};
+
+export async function GET(
+  request: Request,
+  { params }: { params: Promise<{ filename: string }> }
+) {
+  const { filename } = await params;
+  const data = await readBrandingFile(filename);
+  if (!data) return new Response("Not found", { status: 404 });
+
+  const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+  const contentType = CONTENT_TYPES[ext] ?? "application/octet-stream";
+
+  return new Response(new Uint8Array(data), {
+    headers: {
+      "Content-Type": contentType,
+      // Dateinamen tragen bereits einen Date.now()-Suffix, ein neuer
+      // Upload bekommt also automatisch einen neuen Namen.
+      "Cache-Control": "public, max-age=31536000, immutable",
+    },
+  });
+}
@@ -0,0 +1,123 @@
+import { query } from "@/lib/db";
+import { loadMenuEntries } from "@/lib/db/menu-entries";
+import { listClosedDays } from "@/lib/db/closed-days";
+import { addDays, entriesFor, formatPrice, mondayOf, todayISO } from "@/lib/menu";
+import { localized, SITE_TITLE } from "@/lib/types";
+import type { Section } from "@/lib/types";
+
+// RSS-Feed mit dem Speiseplan – ein Eintrag pro Tag mit Gerichten,
+// damit man ihn in einem Feedreader abonnieren kann und täglich sieht,
+// was es gibt. Immer auf Deutsch: Feedreader senden kein Sprach-Cookie,
+// eine feste Sprache ist hier verständlicher als ein zufälliger Locale-Default.
+export const dynamic = "force-dynamic";
+
+function escapeXml(text: string): string {
+  return text.replace(/[&<>"']/g, (c) => {
+    switch (c) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      default:
+        return "&apos;";
+    }
+  });
+}
+
+function formatFeedDate(iso: string): string {
+  const d = new Date(`${iso}T00:00:00Z`);
+  return d.toLocaleDateString("de-DE", {
+    weekday: "long",
+    day: "numeric",
+    month: "long",
+    year: "numeric",
+    timeZone: "UTC",
+  });
+}
+
+export async function GET() {
+  const appUrl = (process.env.APP_URL ?? "http://localhost:3000").replace(/\/$/, "");
+  const monday = mondayOf(todayISO());
+  // Aktuelle + nächste Woche, wie auch die öffentliche Speisekarte per
+  // Wochennavigation anzeigt.
+  const rangeEnd = addDays(monday, 11);
+
+  const [sections, entries, closedDays] = await Promise.all([
+    query<Section>("select * from sections order by sort"),
+    loadMenuEntries(monday, rangeEnd),
+    listClosedDays(monday, rangeEnd),
+  ]);
+
+  const days = Array.from(
+    new Set([...entries.map((e) => e.menu_date), ...closedDays.map((c) => c.closed_date)])
+  ).sort();
+
+  const items = days
+    .map((iso) => {
+      const closed = closedDays.find((c) => c.closed_date === iso);
+      const dayContent = closed
+        ? `<p><strong>Geschlossen</strong>${
+            closed.reason ? ` – ${escapeXml(closed.reason)}` : ""
+          }</p>`
+        : sections
+            .map((s) => {
+              const dishes = entriesFor(entries, iso, s.key);
+              if (dishes.length === 0) return "";
+              const list = dishes
+                .map(
+                  (e) =>
+                    `<li>${escapeXml(localized(e.dish, "de"))} – ${formatPrice(e.dish.price)}</li>`
+                )
+                .join("");
+              return `<p><strong>${escapeXml(localized(s, "de"))} (${escapeXml(
+                s.time_range
+              )})</strong></p><ul>${list}</ul>`;
+            })
+            .join("");
+      if (!dayContent) return "";
+
+      const [y, m, d] = iso.split("-").map(Number);
+      const pubDate = new Date(Date.UTC(y, m - 1, d, 6, 0, 0)).toUTCString();
+
+      return `    <item>
+      <title>${escapeXml(formatFeedDate(iso))}</title>
+      <link>${appUrl}/?woche=${mondayOf(iso)}</link>
+      <guid isPermaLink="false">${appUrl}/feed.xml#${iso}</guid>
+      <pubDate>${pubDate}</pubDate>
+      <description><![CDATA[${dayContent}]]></description>
+      <content:encoded><![CDATA[${dayContent}]]></content:encoded>
+    </item>`;
+    })
+    .join("\n");
+
+  // "description" gilt bei vielen Feed-Readern (Thunderbird, Outlook,
+  // etliche Apps) als reine Kurzfassung/Vorschau und wird eigenmächtig
+  // gekürzt – dadurch war z. B. bei mehreren Essenszeiten pro Tag oft nur
+  // die erste sichtbar. "content:encoded" (RSS-Content-Modul) gilt als
+  // vollständiger Artikeltext und wird von den meisten Readern
+  // ungekürzt angezeigt, wenn vorhanden – redundant zu description für
+  // Reader ohne Unterstützung des Moduls.
+  const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
+  <channel>
+    <title>${escapeXml(SITE_TITLE)} – Speiseplan</title>
+    <link>${appUrl}</link>
+    <description>Täglicher Speiseplan der Kantine</description>
+    <language>de</language>
+    <lastBuildDate>${new Date().toUTCString()}</lastBuildDate>
+${items}
+  </channel>
+</rss>
+`;
+
+  return new Response(xml, {
+    headers: {
+      "Content-Type": "application/rss+xml; charset=utf-8",
+      "Cache-Control": "public, max-age=1800",
+    },
+  });
+}
@@ -1,7 +1,7 @@
@import "tailwindcss";

 /* Farb-Variablen: Defaults entsprechen r-hofmann.de; werden zur Laufzeit
-   aus den Einstellungen (Supabase settings.colors) überschrieben. */
+   aus den Einstellungen (settings.colors) überschrieben. */
 :root {
  --c-primary: #003388;
  --c-primary-dark: #0d315c;
@@ -102,9 +102,41 @@ body {
  font-size: 0.85rem;
 }
 .menu-table tr:nth-child(even) td.cell { background: var(--c-row-bg-alt); }
+.menu-table td.cell.closed-cell {
+  vertical-align: middle;
+  background: #fee2e2;
+}
 .menu-table td.cell .dish { margin-bottom: 0.35rem; }
 .menu-table td.cell .dish sup {
  font-size: 0.6rem;
  color: #4b5563;
  margin-left: 0.15rem;
 }
+
+/* ---------- Chip-Auswahl (Allergene/Zusatzstoffe je Gericht) ---------- */
+.chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  border-radius: 9999px;
+  padding: 0.2rem 0.65rem;
+  font-size: 0.75rem;
+  line-height: 1.2;
+  border: 1px solid #d1d5db;
+  background: #f9fafb;
+  color: #374151;
+  cursor: pointer;
+  transition: background 0.15s ease, border-color 0.15s ease, color 0.15s ease;
+}
+.chip:hover { border-color: var(--c-primary); }
+.chip-active {
+  background: var(--c-primary);
+  border-color: var(--c-primary);
+  color: #ffffff;
+}
+.dish-codes {
+  font-size: 0.65rem;
+  color: #6b7280;
+  vertical-align: super;
+  margin-left: 0.15rem;
+}
@@ -0,0 +1,5 @@
+import SectionManager from "@/components/SectionManager";
+
+export default function EssenszeitenPage() {
+  return <SectionManager />;
+}
@@ -1,5 +1,5 @@
 import DishManager from "@/components/DishManager";

 export default function GerichtePage() {
-  return <DishManager />;
+  return <DishManager translateEnabled={!!process.env.DEEPL_API_KEY} />;
 }
@@ -1,18 +1,15 @@
 import CodeListManager from "@/components/CodeListManager";
+import LabelingNoticeEditor from "@/components/LabelingNoticeEditor";

 export default function KennzeichnungPage() {
+  const translateEnabled = !!process.env.DEEPL_API_KEY;
  return (
+    <div className="flex flex-col gap-6">
+      <LabelingNoticeEditor />
      <div className="grid gap-6 lg:grid-cols-2">
-      <CodeListManager
-        table="allergens"
-        title="Allergene"
-        codeLabel="Kürzel (z. B. A)"
-      />
-      <CodeListManager
-        table="additives"
-        title="Zusatzstoffe"
-        codeLabel="Kürzel (z. B. 1)"
-      />
+        <CodeListManager table="allergens" translateEnabled={translateEnabled} />
+        <CodeListManager table="additives" translateEnabled={translateEnabled} />
+      </div>
    </div>
  );
 }
@@ -1,5 +1,5 @@
 import { redirect } from "next/navigation";
-import { createClient } from "@/lib/supabase/server";
+import { getSession } from "@/lib/auth/session";
 import AppHeader from "@/components/AppHeader";

 export default async function InternLayout({
@@ -7,24 +7,14 @@ export default async function InternLayout({
 }: {
  children: React.ReactNode;
 }) {
-  const supabase = await createClient();
-  const {
-    data: { user },
-  } = await supabase.auth.getUser();
-  if (!user) redirect("/login");
-
-  const { data: profile } = await supabase
-    .from("profiles")
-    .select("role, full_name")
-    .eq("id", user.id)
-    .single();
-  if (!profile || !["staff", "admin"].includes(profile.role)) redirect("/");
+  const session = await getSession();
+  if (!session) redirect("/login");

  return (
    <div className="flex-1 flex flex-col">
      <AppHeader
-        role={profile.role}
-        displayName={profile.full_name || user.email || ""}
+        role={session.user.role}
+        displayName={session.user.full_name || session.user.email}
      />
      <main className="max-w-[1600px] mx-auto w-full px-4 py-6 flex-1">
        {children}
@@ -7,5 +7,10 @@ export default async function InternPage({
  searchParams: Promise<{ woche?: string }>;
 }) {
  const { woche } = await searchParams;
-  return <WeekEditor monday={mondayOf(woche)} />;
+  return (
+    <WeekEditor
+      monday={mondayOf(woche)}
+      translateEnabled={!!process.env.DEEPL_API_KEY}
+    />
+  );
 }
@@ -0,0 +1,5 @@
+import SuggestionReview from "@/components/SuggestionReview";
+
+export default function VorschlaegePage() {
+  return <SuggestionReview />;
+}
@@ -1,33 +1,24 @@
 import { redirect } from "next/navigation";
-import { createClient } from "@/lib/supabase/server";
+import { getSession } from "@/lib/auth/session";
 import AppHeader from "@/components/AppHeader";
 import AccountManager from "@/components/AccountManager";

 export default async function KontoPage() {
-  const supabase = await createClient();
-  const {
-    data: { user },
-  } = await supabase.auth.getUser();
-  if (!user) redirect("/login");
-
-  const { data: profile } = await supabase
-    .from("profiles")
-    .select("role, full_name")
-    .eq("id", user.id)
-    .single();
-  if (!profile || !["staff", "admin"].includes(profile.role)) redirect("/");
+  const session = await getSession();
+  if (!session) redirect("/login");

  return (
    <div className="flex-1 flex flex-col">
      <AppHeader
-        role={profile.role}
-        displayName={profile.full_name || user.email || ""}
+        role={session.user.role}
+        displayName={session.user.full_name || session.user.email}
      />
      <main className="max-w-[1600px] mx-auto w-full px-4 py-6 flex-1">
        <AccountManager
-          role={profile.role}
-          initialFullName={profile.full_name ?? ""}
-          initialEmail={user.email ?? ""}
+          role={session.user.role}
+          initialFullName={session.user.full_name}
+          initialEmail={session.user.email}
+          initialPasswordAuthEnabled={session.user.password_auth_enabled}
        />
      </main>
    </div>
@@ -1,11 +1,14 @@
 import type { Metadata } from "next";
 import { Geist } from "next/font/google";
 import "./globals.css";
-import { createClient } from "@/lib/supabase/server";
-import { COLOR_VARS, DEFAULT_COLORS } from "@/lib/types";
+import { getSettings } from "@/lib/db/settings";
+import { COLOR_VARS, DEFAULT_COLORS, faviconUrl, SITE_TITLE } from "@/lib/types";
+import { getDictionary, getLocale } from "@/lib/i18n";
+import { listLanguages } from "@/lib/db/languages";
+import { LocaleProvider } from "@/components/i18n/LocaleProvider";
 import packageJson from "@/package.json";

-// Farben/Logo sollen Änderungen sofort widerspiegeln.
+// Farben/Logo/Favicon sollen Änderungen sofort widerspiegeln.
 export const dynamic = "force-dynamic";

 const geistSans = Geist({
@@ -13,35 +16,56 @@ const geistSans = Geist({
  subsets: ["latin"],
 });

-export const metadata: Metadata = {
-  title: "Canteen Menu",
+export async function generateMetadata(): Promise<Metadata> {
+  const settings = await getSettings();
+
+  return {
+    title: SITE_TITLE,
    description: "Speisekarte der Betriebskantine",
+    // Immer explizit setzen: app/favicon.ico würde sonst zusätzlich zu
+    // einem eigenen Favicon eingebunden (Next.js kombiniert Datei-
+    // Konvention und Metadata statt sie zu ersetzen).
+    icons: { icon: faviconUrl(settings?.favicon_path) ?? "/favicon.ico" },
+    // Autodiscovery für Feedreader (Browser zeigen dafür kein eigenes
+    // Icon mehr an, daher zusätzlich ein sichtbares RSS-Icon im Header
+    // der öffentlichen Speisekarte, s. app/page.tsx).
+    alternates: {
+      types: {
+        "application/rss+xml": [{ url: "/feed.xml", title: `${SITE_TITLE} – Speiseplan` }],
+      },
+    },
  };
+}

 export default async function RootLayout({
  children,
 }: Readonly<{
  children: React.ReactNode;
 }>) {
-  const supabase = await createClient();
-  const { data: settings } = await supabase
-    .from("settings")
-    .select("colors")
-    .eq("id", 1)
-    .maybeSingle();
+  const [settings, locale, allLanguages] = await Promise.all([
+    getSettings(),
+    getLocale(),
+    listLanguages(),
+  ]);
+  const dict = await getDictionary(locale);
+  const languages = allLanguages
+    .filter((l) => l.active)
+    .map((l) => ({ code: l.code, label: l.label }));

  const colors: Record<string, string> = {
    ...DEFAULT_COLORS,
-    ...((settings?.colors as Record<string, string>) ?? {}),
+    ...(settings?.colors ?? {}),
  };
  const style = Object.fromEntries(
    Object.entries(COLOR_VARS).map(([key, cssVar]) => [cssVar, colors[key]])
  ) as React.CSSProperties;

  return (
-    <html lang="de" className={`${geistSans.variable} h-full antialiased`}>
+    <html lang={locale} className={`${geistSans.variable} h-full antialiased`}>
      <body style={style} className="min-h-full flex flex-col">
+        <LocaleProvider locale={locale} dict={dict} languages={languages}>
          {children}
+        </LocaleProvider>
        <footer className="mt-auto px-4 py-2 text-right text-xs text-gray-400 select-none">
          Version {packageJson.version}
        </footer>
@@ -1,135 +1,11 @@
-"use client";
+import LoginForm from "@/components/LoginForm";
+import { isConfigured } from "@/lib/auth/oidc-config";

-import { useState } from "react";
-import { useRouter } from "next/navigation";
-import Link from "next/link";
-import { createClient } from "@/lib/supabase/client";
-
-function germanAuthError(message: string): string {
-  if (/invalid login credentials/i.test(message))
-    return "E-Mail-Adresse oder Passwort ist falsch.";
-  if (/email not confirmed/i.test(message))
-    return "Die E-Mail-Adresse wurde noch nicht bestätigt.";
-  if (/cancelled|aborted|NotAllowedError/i.test(message))
-    return "Passkey-Anmeldung wurde abgebrochen.";
-  return `Anmeldung fehlgeschlagen: ${message}`;
-}
-
-export default function LoginPage() {
-  const router = useRouter();
-  const supabase = createClient();
-  const [email, setEmail] = useState("");
-  const [password, setPassword] = useState("");
-  const [error, setError] = useState<string | null>(null);
-  const [busy, setBusy] = useState(false);
-
-  async function redirectByRole(userId: string) {
-    const { data: profile } = await supabase
-      .from("profiles")
-      .select("role")
-      .eq("id", userId)
-      .single();
-    router.replace(profile?.role === "admin" ? "/admin" : "/intern");
-    router.refresh();
-  }
-
-  async function signInWithPassword(e: React.FormEvent) {
-    e.preventDefault();
-    setError(null);
-    setBusy(true);
-    const { data, error } = await supabase.auth.signInWithPassword({
-      email,
-      password,
-    });
-    if (error || !data.user) {
-      setError(germanAuthError(error?.message ?? "Unbekannter Fehler"));
-      setBusy(false);
-      return;
-    }
-    await redirectByRole(data.user.id);
-  }
-
-  async function signInWithPasskey() {
-    setError(null);
-    setBusy(true);
-    try {
-      const { data, error } = await supabase.auth.signInWithPasskey();
-      if (error || !data?.user) {
-        setError(
-          germanAuthError(error?.message ?? "Passkey-Anmeldung fehlgeschlagen")
-        );
-        setBusy(false);
-        return;
-      }
-      await redirectByRole(data.user.id);
-    } catch (err) {
-      setError(germanAuthError(err instanceof Error ? err.message : String(err)));
-      setBusy(false);
-    }
-  }
-
-  return (
-    <div className="flex-1 flex items-center justify-center p-4">
-      <div className="card w-full max-w-sm">
-        <h1 className="text-xl font-bold text-[var(--c-primary)] mb-4">
-          Anmeldung
-        </h1>
-        <form onSubmit={signInWithPassword} className="space-y-3">
-          <div>
-            <label className="label" htmlFor="email">
-              E-Mail-Adresse
-            </label>
-            <input
-              id="email"
-              type="email"
-              className="input"
-              value={email}
-              onChange={(e) => setEmail(e.target.value)}
-              autoComplete="username webauthn"
-              required
-            />
-          </div>
-          <div>
-            <label className="label" htmlFor="password">
-              Passwort
-            </label>
-            <input
-              id="password"
-              type="password"
-              className="input"
-              value={password}
-              onChange={(e) => setPassword(e.target.value)}
-              autoComplete="current-password"
-              required
-            />
-          </div>
-          {error && <p className="text-sm text-[var(--c-del)]">{error}</p>}
-          <button type="submit" className="btn btn-primary w-full" disabled={busy}>
-            Anmelden
-          </button>
-        </form>
-
-        <div className="my-4 flex items-center gap-3 text-xs text-gray-400">
-          <span className="h-px flex-1 bg-gray-200" />
-          oder
-          <span className="h-px flex-1 bg-gray-200" />
-        </div>
-
-        <button
-          type="button"
-          onClick={signInWithPasskey}
-          className="btn btn-neutral w-full"
-          disabled={busy}
-        >
-          Mit Passkey anmelden
-        </button>
-
-        <p className="mt-4 text-center text-sm">
-          <Link href="/" className="text-gray-500 hover:text-[var(--c-primary)]">
-            ← Zur Speisekarte
-          </Link>
-        </p>
-      </div>
-    </div>
-  );
+export default async function LoginPage({
+  searchParams,
+}: {
+  searchParams: Promise<{ error?: string }>;
+}) {
+  const { error } = await searchParams;
+  return <LoginForm oidcEnabled={isConfigured()} initialError={error ?? null} />;
 }
@@ -1,13 +1,12 @@
 import { NextResponse } from "next/server";
-import { createClient } from "@/lib/supabase/server";
+import { destroySession } from "@/lib/auth/session";
 import { isSameOrigin } from "@/lib/origin";

 export async function POST(request: Request) {
  if (!isSameOrigin(request)) {
    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
  }
-  const supabase = await createClient();
-  await supabase.auth.signOut();
+  await destroySession();
  // Relative Weiterleitung: bei einer absoluten URL aus request.url landet
  // sonst die Server-Bindung (0.0.0.0) statt des aufgerufenen Hosts im
  // Location-Header.
@@ -1,15 +1,23 @@
 import Link from "next/link";
-import Image from "next/image";
-import { createClient } from "@/lib/supabase/server";
+import { query } from "@/lib/db";
+import { loadMenuEntries } from "@/lib/db/menu-entries";
+import { loadTranslations } from "@/lib/db/translations";
+import { listClosedDays } from "@/lib/db/closed-days";
+import { getSettings } from "@/lib/db/settings";
 import {
  addDays,
+  dishCodes,
+  entriesFor,
  formatDateLong,
  formatPrice,
  mondayOf,
-  WEEKDAYS,
+  todayISO,
 } from "@/lib/menu";
-import { logoUrl } from "@/lib/types";
-import type { CodeItem, MenuEntry, Section } from "@/lib/types";
+import { getDictionary, getLocale } from "@/lib/i18n";
+import { localized, logoUrl, SITE_TITLE } from "@/lib/types";
+import type { CodeItem, Section } from "@/lib/types";
+import PublicMobileMenu from "@/components/PublicMobileMenu";
+import LanguageSwitcher from "@/components/i18n/LanguageSwitcher";

 export default async function Home({
  searchParams,
@@ -19,69 +27,135 @@ export default async function Home({
  const { woche } = await searchParams;
  const monday = mondayOf(woche);
  const friday = addDays(monday, 4);
-  const days = WEEKDAYS.map((weekday, i) => ({
+  const currentWeek = mondayOf(todayISO());
+  const locale = await getLocale();
+  const dict = await getDictionary(locale);
+  const days = dict.weekdays.long.map((weekday, i) => ({
    weekday,
    iso: addDays(monday, i),
  }));

-  const supabase = await createClient();
-  const [sectionsRes, entriesRes, allergensRes, additivesRes, settingsRes] =
-    await Promise.all([
-      supabase.from("sections").select("*").order("sort"),
-      supabase
-        .from("menu_entries")
-        .select("id, menu_date, section_key, position, dish:dishes(id, name, price)")
-        .gte("menu_date", monday)
-        .lte("menu_date", friday)
-        .order("position")
-        .order("created_at"),
-      supabase.from("allergens").select("*").order("sort"),
-      supabase.from("additives").select("*").order("sort"),
-      supabase.from("settings").select("logo_path").eq("id", 1).maybeSingle(),
+  const [
+    sectionRows,
+    entries,
+    allergenRows,
+    additiveRows,
+    settings,
+    sectionTranslations,
+    allergenTranslations,
+    additiveTranslations,
+    closedDays,
+  ] = await Promise.all([
+    query<Omit<Section, "translations">>("select key, label, time_range, sort from sections order by sort"),
+    loadMenuEntries(monday, friday),
+    query<Omit<CodeItem, "translations">>("select code, name, sort from allergens order by sort"),
+    query<Omit<CodeItem, "translations">>("select code, name, sort from additives order by sort"),
+    getSettings(),
+    loadTranslations("section_translations"),
+    loadTranslations("allergen_translations"),
+    loadTranslations("additive_translations"),
+    listClosedDays(monday, friday),
  ]);
+  const closedDayFor = (iso: string) => closedDays.find((c) => c.closed_date === iso);

-  const sections = (sectionsRes.data ?? []) as Section[];
-  const entries = (entriesRes.data ?? []) as unknown as MenuEntry[];
-  const allergens = (allergensRes.data ?? []) as CodeItem[];
-  const additives = (additivesRes.data ?? []) as CodeItem[];
-  const logo = logoUrl(settingsRes.data?.logo_path);
+  const sections: Section[] = sectionRows.map((s) => ({
+    ...s,
+    translations: sectionTranslations.get(s.key) ?? {},
+  }));
+  const allergens: CodeItem[] = allergenRows.map((a) => ({
+    ...a,
+    translations: allergenTranslations.get(a.code) ?? {},
+  }));
+  const additives: CodeItem[] = additiveRows.map((a) => ({
+    ...a,
+    translations: additiveTranslations.get(a.code) ?? {},
+  }));

-  const cell = (iso: string, sectionKey: string) =>
-    entries.filter((e) => e.menu_date === iso && e.section_key === sectionKey);
+  const logo = logoUrl(settings?.logo_path);
+  const labelingDetailed = (settings?.labeling_mode ?? "detailed") !== "notice";

  return (
    <div className="flex-1 px-4 py-6 max-w-[1600px] mx-auto w-full">
-      {/* Kopfbereich: Logo zentriert, Login-Link rechts */}
-      <header className="relative mb-6">
+      {/* Kopfbereich: Sprache + Login-Link eigene Zeile, Logo zentriert
+          darunter. Kein absolutes Positionieren mehr – ein breites Logo
+          (z. B. ein Banner-Format) konnte sonst mit dem Login-Link
+          kollidieren. */}
+      <header className="mb-6">
+        <div className="flex justify-end items-center gap-3 mb-2">
+          {/* Auf Mobilgeräten übernimmt PublicMobileMenu den
+              Sprachumschalter, hier würde er sonst doppelt erscheinen. */}
+          <div className="hidden sm:block">
+            <LanguageSwitcher variant="light" />
+          </div>
+          <a
+            href="/feed.xml"
+            title={dict.publicMenu.rssFeed}
+            aria-label={dict.publicMenu.rssFeed}
+            className="text-gray-400 hover:text-[#ee802f]"
+          >
+            <svg
+              xmlns="http://www.w3.org/2000/svg"
+              viewBox="0 0 24 24"
+              width="18"
+              height="18"
+              fill="currentColor"
+              aria-hidden="true"
+            >
+              <circle cx="5.5" cy="18.5" r="2.5" />
+              <path d="M4 11a9 9 0 0 1 9 9h-3a6 6 0 0 0-6-6v-3z" />
+              <path d="M4 4a16 16 0 0 1 16 16h-3A13 13 0 0 0 4 7V4z" />
+            </svg>
+          </a>
+          <Link
+            href="/login"
+            className="text-sm text-gray-500 hover:text-[var(--c-primary)]"
+          >
+            {dict.common.login}
+          </Link>
+        </div>
        <div className="flex justify-center">
          {logo ? (
            // eslint-disable-next-line @next/next/no-img-element
-            <img src={logo} alt="Logo" className="h-20 object-contain" />
+            <img
+              src={logo}
+              alt="Logo"
+              className="h-20 max-w-full object-contain"
+            />
          ) : (
            <h1 className="text-4xl font-extrabold tracking-tight text-[var(--c-primary)]">
-              Speisekarte
+              {SITE_TITLE}
            </h1>
          )}
        </div>
-        <Link
-          href="/login"
-          className="absolute right-0 top-0 text-sm text-gray-500 hover:text-[var(--c-primary)]"
-        >
-          Anmelden
-        </Link>
      </header>

-      {/* Wochen-Navigation */}
-      <div className="flex gap-3 mb-4">
+      {/* Mobil: Tag (Standard) oder Woche umschaltbar */}
+      <PublicMobileMenu
+        monday={monday}
+        sections={sections}
+        entries={entries}
+        closedDays={closedDays}
+        showLabeling={labelingDetailed}
+      />
+
+      {/* Ab "sm": klassische Wochentabelle */}
+      <div className="hidden sm:block">
+        <div className="flex flex-wrap items-center gap-3 mb-4">
          <Link href={`/?woche=${addDays(monday, -7)}`} className="btn btn-add">
-          ← Vorherige Woche
+            {dict.publicMenu.prevWeek}
+          </Link>
+          <Link href={`/?woche=${currentWeek}`} className="btn btn-primary">
+            {dict.publicMenu.today}
          </Link>
          <Link href={`/?woche=${addDays(monday, 7)}`} className="btn btn-add">
-          Nächste Woche →
+            {dict.publicMenu.nextWeek}
+          </Link>
+          <Link href="/vorschlag" className="btn btn-neutral ml-auto">
+            {dict.publicMenu.suggestDish}
          </Link>
        </div>

-      {/* Speisekarte */}
+        <div className="overflow-x-auto">
          <table className="menu-table">
            <thead>
              <tr>
@@ -90,59 +164,115 @@ export default async function Home({
                  <th key={d.iso} className="day-head">
                    <span className="font-bold">{d.weekday}</span>
                    <br />
-                {formatDateLong(d.iso)}
+                    {formatDateLong(d.iso, dict.dateLocale)}
                  </th>
                ))}
              </tr>
            </thead>
            <tbody>
-          {sections.map((s) => (
+              {sections.map((s, sIdx) => (
                <tr key={s.key}>
                  <th className="section-head">
-                <div>{s.label}</div>
+                    <div>{localized(s, locale)}</div>
                    <div className="time">{s.time_range}</div>
                  </th>
-              {days.map((d) => (
+                  {days.map((d) => {
+                    const closed = closedDayFor(d.iso);
+                    if (closed) {
+                      if (sIdx > 0) return null;
+                      return (
+                        <td key={d.iso} className="cell closed-cell" rowSpan={sections.length}>
+                          <div className="flex flex-col items-center justify-center gap-1 py-4 text-red-700">
+                            <span className="text-2xl" aria-hidden>
+                              🔒
+                            </span>
+                            <span className="font-semibold">{dict.publicMenu.closedLabel}</span>
+                            {localized(closed, locale) && (
+                              <span className="text-sm px-2 text-center">
+                                {localized(closed, locale)}
+                              </span>
+                            )}
+                          </div>
+                        </td>
+                      );
+                    }
+                    return (
                      <td key={d.iso} className="cell">
-                  {cell(d.iso, s.key).map((e) => (
+                        {entriesFor(entries, d.iso, s.key).map((e) => {
+                          const codes = dishCodes(e.dish);
+                          return (
                            <div key={e.id} className="dish">
-                      <span className="font-bold">{e.dish.name}</span>
+                              <span className="font-bold">
+                                {localized(e.dish, locale)}
+                              </span>
+                              {labelingDetailed && codes && (
+                                <sup className="dish-codes">{codes}</sup>
+                              )}
                              {" – "}
                              {formatPrice(e.dish.price)}
                            </div>
-                  ))}
+                          );
+                        })}
                      </td>
-              ))}
+                    );
+                  })}
                </tr>
              ))}
            </tbody>
          </table>
+        </div>
+      </div>

-      {/* Allergene & Zusatzstoffe (gelten für die komplette Speisekarte) */}
+      {/* Allergene & Zusatzstoffe: entweder Legende zu den Kürzeln bei den
+          Gerichten, oder – falls im Hinweismodus – nur ein Hinweistext. */}
+      {labelingDetailed ? (
        <section className="mt-8 grid gap-6 sm:grid-cols-2 text-sm text-gray-700">
          <div>
-          <h2 className="font-bold text-[var(--c-primary)] mb-2">Allergene</h2>
+            <h2 className="font-bold text-[var(--c-primary)] mb-2">
+              {dict.publicMenu.allergens}
+            </h2>
            <ul className="space-y-0.5">
              {allergens.map((a) => (
                <li key={a.code}>
-                <span className="font-semibold">{a.code}</span> – {a.name}
+                  <span className="font-semibold">{a.code}</span> –{" "}
+                  {localized(a, locale)}
                </li>
              ))}
            </ul>
          </div>
          <div>
            <h2 className="font-bold text-[var(--c-primary)] mb-2">
-            Zusatzstoffe
+              {dict.publicMenu.additives}
            </h2>
            <ul className="space-y-0.5">
              {additives.map((a) => (
                <li key={a.code}>
-                <span className="font-semibold">{a.code}</span> – {a.name}
+                  <span className="font-semibold">{a.code}</span> –{" "}
+                  {localized(a, locale)}
                </li>
              ))}
            </ul>
          </div>
        </section>
+      ) : (
+        settings && (
+          <section className="mt-8 text-sm text-gray-700">
+            <h2 className="font-bold text-[var(--c-primary)] mb-2">
+              {dict.publicMenu.labelingNoticeTitle}
+            </h2>
+            <p>
+              {localized(
+                {
+                  name: settings.labeling_notice,
+                  name_en: settings.labeling_notice_en,
+                  name_pl: settings.labeling_notice_pl,
+                },
+                locale
+              )}
+            </p>
+          </section>
+        )
+      )}
    </div>
  );
 }
@@ -0,0 +1,5 @@
+import SuggestionForm from "@/components/SuggestionForm";
+
+export default function VorschlagPage() {
+  return <SuggestionForm />;
+}
@@ -1,36 +1,36 @@
 "use client";

-import { useMemo, useState } from "react";
+import { useEffect, useState } from "react";
 import { useRouter } from "next/navigation";
-import { createClient } from "@/lib/supabase/client";
+import { formatMessage } from "@/lib/i18n/shared";
 import PasskeyManager from "@/components/PasskeyManager";
+import { useDict } from "@/components/i18n/LocaleProvider";

-const ROLE_LABELS: Record<string, string> = {
-  admin: "Administrator",
-  staff: "Kantinenmitarbeiter",
-};
-
-function germanAuthError(message: string): string {
-  if (/invalid login credentials/i.test(message))
-    return "Das aktuelle Passwort ist falsch.";
-  if (/should be at least/i.test(message))
-    return "Das neue Passwort ist zu kurz (mindestens 8 Zeichen).";
-  if (/email.*already|already.*registered/i.test(message))
-    return "Diese E-Mail-Adresse wird bereits verwendet.";
-  return message;
+function errorMessage(
+  dict: ReturnType<typeof useDict>,
+  code: string,
+  fallback: string
+): string {
+  if (code === "wrong_password") return dict.account.wrongCurrentPassword;
+  if (code === "email_used") return dict.account.emailAlreadyUsed;
+  if (code === "needs_passkey") return dict.account.passwordAuthNeedsPasskey;
+  return fallback;
 }

 export default function AccountManager({
  role,
  initialFullName,
  initialEmail,
+  initialPasswordAuthEnabled,
 }: {
  role: string;
  initialFullName: string;
  initialEmail: string;
+  initialPasswordAuthEnabled: boolean;
 }) {
-  const supabase = useMemo(() => createClient(), []);
  const router = useRouter();
+  const dict = useDict();
+  const roleLabel = role === "admin" ? dict.common.roleAdmin : dict.common.roleStaff;

  // Persönliche Daten
  const [fullName, setFullName] = useState(initialFullName);
@@ -40,6 +40,7 @@ export default function AccountManager({

  // E-Mail-Adresse
  const [email, setEmail] = useState(initialEmail);
+  const [emailPassword, setEmailPassword] = useState("");
  const [emailError, setEmailError] = useState<string | null>(null);
  const [emailInfo, setEmailInfo] = useState<string | null>(null);
  const [emailBusy, setEmailBusy] = useState(false);
@@ -52,23 +53,45 @@ export default function AccountManager({
  const [pwInfo, setPwInfo] = useState<string | null>(null);
  const [pwBusy, setPwBusy] = useState(false);

+  // Passwort-Anmeldung an/aus
+  const [passwordAuthEnabled, setPasswordAuthEnabled] = useState(
+    initialPasswordAuthEnabled
+  );
+  const [passkeyCount, setPasskeyCount] = useState<number | null>(null);
+  const [authError, setAuthError] = useState<string | null>(null);
+  const [authInfo, setAuthInfo] = useState<string | null>(null);
+  const [authBusy, setAuthBusy] = useState(false);
+
+  useEffect(() => {
+    fetch("/api/auth/passkeys")
+      .then((res) => (res.ok ? res.json() : []))
+      .then((data) => setPasskeyCount(data.length));
+  }, []);
+
  async function saveName(e: React.FormEvent) {
    e.preventDefault();
    setNameError(null);
    setNameInfo(null);
    const name = fullName.trim();
    if (!name) {
-      setNameError("Bitte einen Namen angeben.");
+      setNameError(dict.account.nameRequired);
      return;
    }
    setNameBusy(true);
-    const { error } = await supabase
-      .from("profiles")
-      .update({ full_name: name })
-      .eq("id", (await supabase.auth.getUser()).data.user?.id ?? "");
-    if (error) setNameError(`Speichern fehlgeschlagen: ${error.message}`);
-    else {
-      setNameInfo("Name gespeichert.");
+    const res = await fetch("/api/account", {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ full_name: name }),
+    });
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      setNameError(
+        formatMessage(dict.account.saveError, {
+          message: errorMessage(dict, data.error, data.error ?? String(res.status)),
+        })
+      );
+    } else {
+      setNameInfo(dict.account.nameSaved);
      router.refresh();
    }
    setNameBusy(false);
@@ -81,13 +104,22 @@ export default function AccountManager({
    const next = email.trim();
    if (!next || next === initialEmail) return;
    setEmailBusy(true);
-    const { error } = await supabase.auth.updateUser({ email: next });
-    if (error) {
-      setEmailError(`Ändern fehlgeschlagen: ${germanAuthError(error.message)}`);
-    } else {
-      setEmailInfo(
-        "Bestätigungs-E-Mails wurden verschickt. Die neue Adresse wird erst nach Bestätigung des Links aktiv."
+    const res = await fetch("/api/account/email", {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email: next, password: emailPassword }),
+    });
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      setEmailError(
+        formatMessage(dict.account.changeError, {
+          message: errorMessage(dict, data.error, data.error ?? String(res.status)),
+        })
      );
+    } else {
+      setEmailInfo(dict.account.emailChanged);
+      setEmailPassword("");
+      router.refresh();
    }
    setEmailBusy(false);
  }
@@ -97,31 +129,29 @@ export default function AccountManager({
    setPwError(null);
    setPwInfo(null);
    if (newPassword.length < 8) {
-      setPwError("Das neue Passwort muss mindestens 8 Zeichen lang sein.");
+      setPwError(dict.account.passwordTooShort);
      return;
    }
    if (newPassword !== newPasswordRepeat) {
-      setPwError("Die Passwörter stimmen nicht überein.");
+      setPwError(dict.account.passwordMismatch);
      return;
    }
    setPwBusy(true);

-    // Zur Verifizierung: aktuelles Passwort gegenprüfen, bevor geändert wird.
-    const { error: verifyError } = await supabase.auth.signInWithPassword({
-      email: initialEmail,
-      password: currentPassword,
+    const res = await fetch("/api/account/password", {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ currentPassword, newPassword }),
    });
-    if (verifyError) {
-      setPwError(germanAuthError(verifyError.message));
-      setPwBusy(false);
-      return;
-    }
-
-    const { error } = await supabase.auth.updateUser({ password: newPassword });
-    if (error) {
-      setPwError(`Ändern fehlgeschlagen: ${germanAuthError(error.message)}`);
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      setPwError(
+        formatMessage(dict.account.changeError, {
+          message: errorMessage(dict, data.error, data.error ?? String(res.status)),
+        })
+      );
    } else {
-      setPwInfo("Passwort geändert.");
+      setPwInfo(dict.account.passwordChanged);
      setCurrentPassword("");
      setNewPassword("");
      setNewPasswordRepeat("");
@@ -129,21 +159,55 @@ export default function AccountManager({
    setPwBusy(false);
  }

+  async function togglePasswordAuth() {
+    setAuthError(null);
+    setAuthInfo(null);
+    const next = !passwordAuthEnabled;
+    if (!next && (passkeyCount ?? 0) === 0) {
+      setAuthError(dict.account.passwordAuthNeedsPasskey);
+      return;
+    }
+    if (!next && !window.confirm(dict.account.confirmDisablePasswordAuth)) return;
+
+    setAuthBusy(true);
+    const res = await fetch("/api/account", {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ password_auth_enabled: next }),
+    });
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      setAuthError(
+        formatMessage(dict.account.saveError, {
+          message: errorMessage(dict, data.error, data.error ?? String(res.status)),
+        })
+      );
+    } else {
+      setPasswordAuthEnabled(next);
+      setAuthInfo(
+        next ? dict.account.passwordAuthEnabled : dict.account.passwordAuthDisabled
+      );
+    }
+    setAuthBusy(false);
+  }
+
  return (
    <div className="max-w-3xl space-y-6">
      <div>
-        <h1 className="text-xl font-bold text-[var(--c-primary)]">Mein Konto</h1>
+        <h1 className="text-xl font-bold text-[var(--c-primary)]">
+          {dict.account.title}
+        </h1>
        <p className="text-sm text-gray-500">
-          {initialEmail} – {ROLE_LABELS[role] ?? role}
+          {initialEmail} – {roleLabel}
        </p>
      </div>

      <section className="card">
-        <h2 className="font-semibold mb-3">Persönliche Daten</h2>
+        <h2 className="font-semibold mb-3">{dict.account.personalTitle}</h2>
        <form onSubmit={saveName} className="space-y-3">
          <div className="max-w-80">
            <label className="label" htmlFor="account-name">
-              Name
+              {dict.common.name}
            </label>
            <input
              id="account-name"
@@ -160,17 +224,17 @@ export default function AccountManager({
          )}
          {nameInfo && <p className="text-sm text-green-700">{nameInfo}</p>}
          <button type="submit" className="btn btn-add" disabled={nameBusy}>
-            Name speichern
+            {dict.account.saveName}
          </button>
        </form>
      </section>

      <section className="card">
-        <h2 className="font-semibold mb-3">E-Mail-Adresse</h2>
+        <h2 className="font-semibold mb-3">{dict.account.emailTitle}</h2>
        <form onSubmit={saveEmail} className="space-y-3">
          <div className="max-w-80">
            <label className="label" htmlFor="account-email">
-              E-Mail-Adresse
+              {dict.common.email}
            </label>
            <input
              id="account-email"
@@ -181,6 +245,20 @@ export default function AccountManager({
              required
            />
          </div>
+          <div className="max-w-80">
+            <label className="label" htmlFor="account-email-password">
+              {dict.account.currentPassword}
+            </label>
+            <input
+              id="account-email-password"
+              type="password"
+              className="input"
+              value={emailPassword}
+              onChange={(e) => setEmailPassword(e.target.value)}
+              autoComplete="current-password"
+              required
+            />
+          </div>
          {emailError && (
            <p className="text-sm text-[var(--c-del)]" role="alert">
              {emailError}
@@ -192,17 +270,17 @@ export default function AccountManager({
            className="btn btn-add"
            disabled={emailBusy || email.trim() === initialEmail}
          >
-            E-Mail-Adresse ändern
+            {dict.account.changeEmail}
          </button>
        </form>
      </section>

      <section className="card">
-        <h2 className="font-semibold mb-3">Passwort ändern</h2>
+        <h2 className="font-semibold mb-3">{dict.account.passwordTitle}</h2>
        <form onSubmit={savePassword} className="space-y-3">
          <div className="max-w-80">
            <label className="label" htmlFor="account-current-password">
-              Aktuelles Passwort (zur Verifizierung)
+              {dict.account.currentPassword}
            </label>
            <input
              id="account-current-password"
@@ -216,7 +294,7 @@ export default function AccountManager({
          </div>
          <div className="max-w-80">
            <label className="label" htmlFor="account-new-password">
-              Neues Passwort
+              {dict.account.newPassword}
            </label>
            <input
              id="account-new-password"
@@ -231,7 +309,7 @@ export default function AccountManager({
          </div>
          <div className="max-w-80">
            <label className="label" htmlFor="account-new-password-repeat">
-              Neues Passwort wiederholen
+              {dict.account.newPasswordRepeat}
            </label>
            <input
              id="account-new-password-repeat"
@@ -251,11 +329,31 @@ export default function AccountManager({
          )}
          {pwInfo && <p className="text-sm text-green-700">{pwInfo}</p>}
          <button type="submit" className="btn btn-add" disabled={pwBusy}>
-            Passwort ändern
+            {dict.account.changePassword}
          </button>
        </form>
      </section>

+      <section className="card">
+        <h2 className="font-semibold mb-1">{dict.account.passwordAuthTitle}</h2>
+        <p className="text-sm text-gray-600 mb-3">{dict.account.passwordAuthHint}</p>
+        {authError && (
+          <p className="mb-2 text-sm text-[var(--c-del)]" role="alert">
+            {authError}
+          </p>
+        )}
+        {authInfo && <p className="mb-2 text-sm text-green-700">{authInfo}</p>}
+        <label className="flex items-center gap-2 cursor-pointer text-sm w-fit">
+          <input
+            type="checkbox"
+            checked={passwordAuthEnabled}
+            onChange={togglePasswordAuth}
+            disabled={authBusy || passkeyCount === null}
+          />
+          {dict.account.passwordAuthCheckbox}
+        </label>
+      </section>
+
      <PasskeyManager />
    </div>
  );
@@ -3,22 +3,21 @@
 // Gemeinsamer Kopfbereich für alle internen Seiten. Statt zweier
 // getrennter Bereiche (Kantine/Verwaltung) gibt es eine Navigation:
 // Admins sehen zusätzlich die Verwaltungs-Links, der aktive Punkt
-// wird hervorgehoben.
+// wird hervorgehoben. Ab "sm" die klassische einzeilige Navigation,
+// darunter ein Hamburger-Menü mit denselben Links gestapelt.

 import Link from "next/link";
 import { usePathname } from "next/navigation";
+import { useEffect, useState } from "react";
 import type { Role } from "@/lib/types";
+import { formatMessage } from "@/lib/i18n/shared";
+import { useDict } from "@/components/i18n/LocaleProvider";
+import LanguageSwitcher from "@/components/i18n/LanguageSwitcher";

-const MENU_LINKS = [
-  { href: "/intern", label: "Wochenplan" },
-  { href: "/intern/gerichte", label: "Gerichte" },
-  { href: "/intern/kennzeichnung", label: "Allergene & Zusatzstoffe" },
-];
-
-const ADMIN_LINKS = [
-  { href: "/admin", label: "Benutzer" },
-  { href: "/admin/design", label: "Design" },
-];
+interface NavLink {
+  href: string;
+  label: string;
+}

 export default function AppHeader({
  role,
@@ -28,44 +27,160 @@ export default function AppHeader({
  displayName: string;
 }) {
  const pathname = usePathname();
+  const dict = useDict();
+  const [suggestionCount, setSuggestionCount] = useState(0);
+  const [mobileOpen, setMobileOpen] = useState(false);
+
+  useEffect(() => {
+    fetch("/api/dish-suggestions")
+      .then((res) => (res.ok ? res.json() : []))
+      .then((data) => setSuggestionCount(Array.isArray(data) ? data.length : 0))
+      .catch(() => {});
+  }, [pathname]);
+
+  // Hamburger-Panel bei jeder Navigation automatisch schließen.
+  useEffect(() => {
+    setMobileOpen(false);
+  }, [pathname]);
+
+  const menuLinks: NavLink[] = [
+    { href: "/intern", label: dict.header.weekPlan },
+    { href: "/intern/essenszeiten", label: dict.header.sections },
+    { href: "/intern/gerichte", label: dict.header.dishes },
+    { href: "/intern/kennzeichnung", label: dict.header.labels },
+    { href: "/intern/vorschlaege", label: dict.header.suggestions },
+  ];
+  const adminLinks: NavLink[] = [
+    { href: "/admin", label: dict.header.users },
+    { href: "/admin/design", label: dict.header.design },
+    { href: "/admin/sprachen", label: dict.header.languages },
+  ];

  const linkClass = (href: string) =>
    `rounded px-2 py-0.5 transition-colors hover:bg-white/10 ${
      pathname === href ? "bg-white/20 font-semibold" : "text-white/90"
    }`;

+  // Von Desktop- und Mobile-Navigation gemeinsam genutzt, damit die
+  // Vorschläge-Badge-Logik nicht doppelt gepflegt werden muss.
+  function renderLinks(links: NavLink[]) {
+    return links.map((l) => (
+      <Link key={l.href} href={l.href} className={`relative ${linkClass(l.href)}`}>
+        {l.label}
+        {l.href === "/intern/vorschlaege" && suggestionCount > 0 && (
+          <span
+            className="absolute -top-1.5 -right-1.5 flex h-4 min-w-4 items-center justify-center rounded-full bg-[var(--c-del)] px-1 text-[10px] font-bold leading-none text-white"
+            aria-label={formatMessage(dict.header.openSuggestions, {
+              count: suggestionCount,
+            })}
+          >
+            {suggestionCount}
+          </span>
+        )}
+      </Link>
+    ));
+  }
+
  return (
    <header className="bg-[var(--c-primary-dark)] text-white">
-      <div className="max-w-[1600px] mx-auto w-full px-4 py-3 flex flex-wrap items-center gap-x-6 gap-y-2 text-sm">
-        <span className="font-bold text-base">Kantine</span>
+      {/* Mobil (< "sm"): kompakte Kopfzeile mit Hamburger-Toggle */}
+      <div className="sm:hidden flex items-center justify-between px-4 py-3">
+        <span className="font-bold text-base">{dict.header.canteen}</span>
+        <button
+          type="button"
+          className="p-1 -m-1"
+          onClick={() => setMobileOpen((v) => !v)}
+          aria-label={dict.header.menuToggle}
+          aria-expanded={mobileOpen}
+        >
+          <svg
+            xmlns="http://www.w3.org/2000/svg"
+            viewBox="0 0 24 24"
+            width="24"
+            height="24"
+            fill="none"
+            stroke="currentColor"
+            strokeWidth="2"
+            strokeLinecap="round"
+            aria-hidden="true"
+          >
+            {mobileOpen ? (
+              <path d="M6 6l12 12M18 6L6 18" />
+            ) : (
+              <path d="M4 7h16M4 12h16M4 17h16" />
+            )}
+          </svg>
+        </button>
+      </div>
+
+      {mobileOpen && (
+        <div className="sm:hidden px-4 pb-4 flex flex-col gap-4 text-sm border-t border-white/10">
+          <nav className="flex flex-col gap-1" aria-label={dict.header.menuGroup}>
+            <span className="mt-3 text-xs uppercase tracking-wider text-white/50">
+              {dict.header.menuGroup}
+            </span>
+            {renderLinks(menuLinks)}
+          </nav>
+
+          {role === "admin" && (
+            <nav className="flex flex-col gap-1" aria-label={dict.header.adminGroup}>
+              <span className="text-xs uppercase tracking-wider text-white/50">
+                {dict.header.adminGroup}
+              </span>
+              {renderLinks(adminLinks)}
+            </nav>
+          )}
+
+          <Link
+            href="/"
+            className="w-fit rounded px-2 py-0.5 text-white/70 hover:bg-white/10"
+          >
+            {dict.header.viewMenu}
+          </Link>
+
+          <div className="flex items-center gap-3 border-t border-white/10 pt-3">
+            <LanguageSwitcher />
+            <Link
+              href="/konto"
+              className={`rounded px-2 py-0.5 hover:bg-white/10 ${
+                pathname === "/konto" ? "bg-white/20 font-semibold" : "text-white/80"
+              }`}
+            >
+              {displayName}
+            </Link>
+          </div>
+
+          <form action="/logout" method="post">
+            <button type="submit" className="btn btn-del w-full">
+              {dict.common.logout}
+            </button>
+          </form>
+        </div>
+      )}
+
+      {/* Ab "sm": bisherige einzeilige Navigation */}
+      <div className="hidden sm:flex max-w-[1600px] mx-auto w-full px-4 py-3 flex-wrap items-center gap-x-6 gap-y-2 text-sm">
+        <span className="font-bold text-base">{dict.header.canteen}</span>

        <nav
          className="flex flex-wrap items-center gap-x-1 gap-y-1"
-          aria-label="Speiseplan"
+          aria-label={dict.header.menuGroup}
        >
          <span className="mr-1 text-xs uppercase tracking-wider text-white/50">
-            Speiseplan
+            {dict.header.menuGroup}
          </span>
-          {MENU_LINKS.map((l) => (
-            <Link key={l.href} href={l.href} className={linkClass(l.href)}>
-              {l.label}
-            </Link>
-          ))}
+          {renderLinks(menuLinks)}
        </nav>

        {role === "admin" && (
          <nav
            className="flex flex-wrap items-center gap-x-1 gap-y-1"
-            aria-label="Verwaltung"
+            aria-label={dict.header.adminGroup}
          >
            <span className="mr-1 text-xs uppercase tracking-wider text-white/50">
-              Verwaltung
+              {dict.header.adminGroup}
            </span>
-            {ADMIN_LINKS.map((l) => (
-              <Link key={l.href} href={l.href} className={linkClass(l.href)}>
-                {l.label}
-              </Link>
-            ))}
+            {renderLinks(adminLinks)}
          </nav>
        )}

@@ -73,13 +188,14 @@ export default function AppHeader({
          href="/"
          className="rounded px-2 py-0.5 text-white/70 hover:bg-white/10"
        >
-          Speisekarte ansehen
+          {dict.header.viewMenu}
        </Link>

        <div className="ml-auto flex items-center gap-3">
+          <LanguageSwitcher />
          <Link
            href="/konto"
-            title="Mein Konto"
+            title={dict.header.myAccount}
            className={`rounded px-2 py-0.5 hover:bg-white/10 ${
              pathname === "/konto"
                ? "bg-white/20 font-semibold"
@@ -90,7 +206,7 @@ export default function AppHeader({
          </Link>
          <form action="/logout" method="post">
            <button type="submit" className="btn btn-del">
-              Abmelden
+              {dict.common.logout}
            </button>
          </form>
        </div>
@@ -0,0 +1,48 @@
+"use client";
+
+import type { CodeItem } from "@/lib/types";
+import { localized } from "@/lib/types";
+import { useDict, useLocale } from "@/components/i18n/LocaleProvider";
+
+export default function ChipPicker({
+  items,
+  selected,
+  onToggle,
+  label,
+}: {
+  items: CodeItem[];
+  selected: string[];
+  onToggle: (code: string) => void;
+  label: string;
+}) {
+  const dict = useDict();
+  const locale = useLocale();
+
+  return (
+    <div>
+      <label className="label">{label}</label>
+      {items.length === 0 ? (
+        <p className="text-sm text-gray-400">{dict.codeList.empty}</p>
+      ) : (
+        <div className="flex flex-wrap gap-1.5">
+          {items.map((item) => {
+            const active = selected.includes(item.code);
+            const name = localized(item, locale);
+            return (
+              <button
+                key={item.code}
+                type="button"
+                onClick={() => onToggle(item.code)}
+                className={`chip ${active ? "chip-active" : ""}`}
+                aria-pressed={active}
+                title={name}
+              >
+                <span className="font-semibold">{item.code}</span> {name}
+              </button>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}
@@ -3,33 +3,48 @@
 // Pflege der globalen Allergen-/Zusatzstofflisten, die unterhalb
 // der öffentlichen Speisekarte angezeigt werden.

-import { useCallback, useEffect, useMemo, useState } from "react";
-import { createClient } from "@/lib/supabase/client";
+import { useCallback, useEffect, useState } from "react";
+import { formatMessage } from "@/lib/i18n/shared";
+import { localized } from "@/lib/types";
 import type { CodeItem } from "@/lib/types";
+import { useDict, useLanguages, useLocale } from "@/components/i18n/LocaleProvider";

 export default function CodeListManager({
  table,
-  title,
-  codeLabel,
+  translateEnabled,
 }: {
  table: "allergens" | "additives";
-  title: string;
-  codeLabel: string;
+  translateEnabled: boolean;
 }) {
-  const supabase = useMemo(() => createClient(), []);
+  const dict = useDict();
+  const locale = useLocale();
+  const languages = useLanguages().filter((l) => l.code !== "de");
+  const title =
+    table === "allergens" ? dict.codeList.allergensTitle : dict.codeList.additivesTitle;
+  const codeLabel =
+    table === "allergens"
+      ? dict.codeList.allergenCodeLabel
+      : dict.codeList.additiveCodeLabel;
+
  const [items, setItems] = useState<CodeItem[]>([]);
  const [editing, setEditing] = useState<{
    original: string | null; // code vor der Bearbeitung, null = neu
    code: string;
    name: string;
+    translations: Record<string, string>;
  } | null>(null);
  const [error, setError] = useState<string | null>(null);
+  const [notice, setNotice] = useState<string | null>(null);
+  const [ioBusy, setIoBusy] = useState(false);
+  const [translateState, setTranslateState] = useState<"idle" | "busy" | "done">(
+    "idle"
+  );

  const load = useCallback(async () => {
-    const { data, error } = await supabase.from(table).select("*").order("sort");
-    if (error) setError(`Laden fehlgeschlagen: ${error.message}`);
-    else setItems(data as CodeItem[]);
-  }, [supabase, table]);
+    const res = await fetch(`/api/${table}`);
+    if (!res.ok) setError(formatMessage(dict.codeList.loadError, { message: String(res.status) }));
+    else setItems(await res.json());
+  }, [table, dict]);

  useEffect(() => {
    load();
@@ -42,24 +57,29 @@ export default function CodeListManager({
    const code = editing.code.trim();
    const name = editing.name.trim();
    if (!code || !name) return;
+    const payload = {
+      code,
+      name,
+      translations: editing.translations,
+    };

-    let dbError;
-    if (editing.original) {
-      ({ error: dbError } = await supabase
-        .from(table)
-        .update({ code, name })
-        .eq("code", editing.original));
-    } else {
-      const maxSort = items.reduce((m, i) => Math.max(m, i.sort), 0);
-      ({ error: dbError } = await supabase
-        .from(table)
-        .insert({ code, name, sort: maxSort + 1 }));
-    }
-    if (dbError) {
+    const res = editing.original
+      ? await fetch(`/api/${table}/${editing.original}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+        })
+      : await fetch(`/api/${table}`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+        });
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
      setError(
-        /duplicate key/i.test(dbError.message)
-          ? `Das Kürzel „${code}“ existiert bereits.`
-          : `Speichern fehlgeschlagen: ${dbError.message}`
+        data.error === "duplicate_code"
+          ? formatMessage(dict.codeList.duplicateCode, { code })
+          : formatMessage(dict.codeList.saveError, { message: data.error ?? String(res.status) })
      );
      return;
    }
@@ -68,25 +88,126 @@ export default function CodeListManager({
  }

  async function remove(item: CodeItem) {
-    if (!window.confirm(`„${item.code} – ${item.name}“ wirklich löschen?`))
+    if (
+      !window.confirm(
+        formatMessage(dict.codeList.confirmDelete, { code: item.code, name: item.name })
+      )
+    )
      return;
-    const { error } = await supabase.from(table).delete().eq("code", item.code);
-    if (error) setError(`Löschen fehlgeschlagen: ${error.message}`);
+    const res = await fetch(`/api/${table}/${item.code}`, { method: "DELETE" });
+    if (!res.ok)
+      setError(formatMessage(dict.codeList.deleteError, { message: String(res.status) }));
+    await load();
+  }
+
+  async function autoTranslate() {
+    if (!editing || !editing.name.trim()) return;
+    setTranslateState("busy");
+    setError(null);
+    try {
+      const res = await fetch("/api/translate", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          table,
+          id: editing.original,
+          text: editing.name.trim(),
+        }),
+      });
+      const data = await res.json();
+      if (!res.ok) throw new Error(data?.error ?? `Fehler (${res.status})`);
+      setEditing((prev) =>
+        prev
+          ? { ...prev, translations: { ...prev.translations, ...(data.translations ?? {}) } }
+          : prev
+      );
+      setTranslateState("done");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      setTranslateState("idle");
+    }
+  }
+
+  async function exportItems() {
+    setError(null);
+    setNotice(null);
+    const res = await fetch(`/api/${table}/export`);
+    if (!res.ok) {
+      setError(formatMessage(dict.codeList.exportError, { message: String(res.status) }));
+      return;
+    }
+    const blob = await res.blob();
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = table === "allergens" ? "allergene.csv" : "zusatzstoffe.csv";
+    a.click();
+    URL.revokeObjectURL(url);
+  }
+
+  async function importItems(e: React.ChangeEvent<HTMLInputElement>) {
+    const file = e.target.files?.[0];
+    e.target.value = "";
+    if (!file) return;
+    setError(null);
+    setNotice(null);
+    setIoBusy(true);
+    const fd = new FormData();
+    fd.append("file", file);
+    const res = await fetch(`/api/${table}/import`, { method: "POST", body: fd });
+    setIoBusy(false);
+    if (!res.ok) {
+      setError(formatMessage(dict.codeList.importError, { message: String(res.status) }));
+      return;
+    }
+    const data = (await res.json()) as {
+      created: number;
+      updated: number;
+      skipped: { row: number; reason: string }[];
+    };
+    let msg = formatMessage(dict.codeList.importSuccess, {
+      created: data.created,
+      updated: data.updated,
+    });
+    if (data.skipped.length > 0) {
+      const reasons = data.skipped
+        .map((s) => formatMessage(dict.codeList.importSkippedRow, s))
+        .join("; ");
+      msg +=
+        " " + formatMessage(dict.codeList.importSkipped, { count: data.skipped.length, reasons });
+    }
+    setNotice(msg);
    await load();
  }

  return (
    <section className="card">
-      <div className="flex items-center gap-3 mb-3">
+      <div className="flex flex-wrap items-center gap-3 mb-3">
        <h2 className="text-lg font-bold text-[var(--c-primary)] mr-auto">
          {title}
        </h2>
+        <button type="button" className="btn btn-neutral" onClick={exportItems}>
+          {dict.codeList.exportButton}
+        </button>
+        <label className="btn btn-neutral cursor-pointer">
+          {dict.codeList.importButton}
+          <input
+            type="file"
+            accept=".csv,text/csv"
+            className="hidden"
+            onChange={importItems}
+            disabled={ioBusy}
+          />
+        </label>
        <button
          type="button"
          className="btn btn-add"
-          onClick={() => setEditing({ original: null, code: "", name: "" })}
+          onClick={() => {
+            setEditing({ original: null, code: "", name: "", translations: {} });
+            setTranslateState("idle");
+          }}
        >
-          Hinzufügen
+          {dict.common.add}
        </button>
      </div>

@@ -95,6 +216,7 @@ export default function CodeListManager({
          {error}
        </p>
      )}
+      {notice && <p className="mb-2 text-sm text-green-700">{notice}</p>}

      {editing && (
        <form onSubmit={save} className="mb-3 space-y-2 border-b border-gray-200 pb-3">
@@ -108,7 +230,7 @@ export default function CodeListManager({
            />
          </div>
          <div>
-            <label className="label">Bezeichnung</label>
+            <label className="label">{dict.codeList.nameLabel}</label>
            <input
              className="input"
              value={editing.name}
@@ -116,16 +238,54 @@ export default function CodeListManager({
              required
            />
          </div>
+          {languages.length > 0 && (
+            <div className="grid gap-2 sm:grid-cols-2">
+              {languages.map((lang) => (
+                <div key={lang.code}>
+                  <label className="label">{lang.label}</label>
+                  <input
+                    className="input"
+                    value={editing.translations[lang.code] ?? ""}
+                    onChange={(e) =>
+                      setEditing({
+                        ...editing,
+                        translations: { ...editing.translations, [lang.code]: e.target.value },
+                      })
+                    }
+                  />
+                </div>
+              ))}
+            </div>
+          )}
+          {translateEnabled && languages.length > 0 && (
+            <div>
+              <button
+                type="button"
+                className="btn btn-neutral"
+                onClick={autoTranslate}
+                disabled={translateState === "busy" || !editing.name.trim()}
+              >
+                {translateState === "busy"
+                  ? dict.dishManager.translating
+                  : dict.dishManager.autoTranslate}
+              </button>
+              {translateState === "done" && (
+                <span className="ml-2 text-sm text-green-700">
+                  {dict.dishManager.translated}
+                </span>
+              )}
+            </div>
+          )}
          <div className="flex gap-2">
            <button type="submit" className="btn btn-add">
-              Speichern
+              {dict.common.save}
            </button>
            <button
              type="button"
              className="btn btn-neutral"
              onClick={() => setEditing(null)}
            >
-              Abbrechen
+              {dict.common.cancel}
            </button>
          </div>
        </form>
@@ -133,34 +293,37 @@ export default function CodeListManager({

      <ul className="divide-y divide-gray-100">
        {items.map((item) => (
-          <li key={item.code} className="flex items-center gap-2 py-1.5 text-sm">
+          <li key={item.code} className="flex flex-wrap items-center gap-2 py-1.5 text-sm">
            <span className="mr-auto">
-              <span className="font-semibold">{item.code}</span> – {item.name}
+              <span className="font-semibold">{item.code}</span> –{" "}
+              {localized(item, locale)}
            </span>
            <button
              type="button"
              className="btn btn-primary"
-              onClick={() =>
+              onClick={() => {
                setEditing({
                  original: item.code,
                  code: item.code,
                  name: item.name,
-                })
-              }
+                  translations: { ...item.translations },
+                });
+                setTranslateState("idle");
+              }}
            >
-              Bearbeiten
+              {dict.common.edit}
            </button>
            <button
              type="button"
              className="btn btn-del"
              onClick={() => remove(item)}
            >
-              Löschen
+              {dict.common.delete}
            </button>
          </li>
        ))}
        {items.length === 0 && (
-          <li className="py-2 text-gray-500 text-sm">Keine Einträge.</li>
+          <li className="py-2 text-gray-500 text-sm">{dict.codeList.empty}</li>
        )}
      </ul>
    </section>
@@ -1,32 +1,44 @@
 "use client";

-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useState } from "react";
 import { useRouter } from "next/navigation";
-import { createClient } from "@/lib/supabase/client";
-import { COLOR_LABELS, DEFAULT_COLORS, logoUrl } from "@/lib/types";
+import { formatMessage } from "@/lib/i18n/shared";
+import { DEFAULT_COLORS, faviconUrl, logoUrl } from "@/lib/types";
+import { useDict } from "@/components/i18n/LocaleProvider";
+
+type AssetKind = "logo" | "favicon";

 export default function DesignEditor() {
-  const supabase = useMemo(() => createClient(), []);
  const router = useRouter();
+  const dict = useDict();
+  const colorLabels: Record<string, string> = {
+    primary: dict.designEditor.colorPrimary,
+    primaryDark: dict.designEditor.colorPrimaryDark,
+    accent: dict.designEditor.colorAccent,
+    headerText: dict.designEditor.colorHeaderText,
+    rowBg: dict.designEditor.colorRowBg,
+    rowBgAlt: dict.designEditor.colorRowBgAlt,
+    addBtn: dict.designEditor.colorAddBtn,
+    deleteBtn: dict.designEditor.colorDeleteBtn,
+  };
  const [colors, setColors] = useState<Record<string, string>>(DEFAULT_COLORS);
  const [logoPath, setLogoPath] = useState<string | null>(null);
+  const [faviconPath, setFaviconPath] = useState<string | null>(null);
  const [error, setError] = useState<string | null>(null);
  const [info, setInfo] = useState<string | null>(null);
  const [busy, setBusy] = useState(false);

  const load = useCallback(async () => {
-    const { data, error } = await supabase
-      .from("settings")
-      .select("colors, logo_path")
-      .eq("id", 1)
-      .maybeSingle();
-    if (error) {
-      setError(`Laden fehlgeschlagen: ${error.message}`);
+    const res = await fetch("/api/settings");
+    if (!res.ok) {
+      setError(formatMessage(dict.designEditor.loadError, { message: String(res.status) }));
      return;
    }
+    const data = await res.json();
    setColors({ ...DEFAULT_COLORS, ...(data?.colors ?? {}) });
    setLogoPath(data?.logo_path ?? null);
-  }, [supabase]);
+    setFaviconPath(data?.favicon_path ?? null);
+  }, [dict]);

  useEffect(() => {
    load();
@@ -36,13 +48,15 @@ export default function DesignEditor() {
    setBusy(true);
    setError(null);
    setInfo(null);
-    const { error } = await supabase
-      .from("settings")
-      .update({ colors })
-      .eq("id", 1);
-    if (error) setError(`Speichern fehlgeschlagen: ${error.message}`);
+    const res = await fetch("/api/settings", {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ colors }),
+    });
+    if (!res.ok)
+      setError(formatMessage(dict.designEditor.saveError, { message: String(res.status) }));
    else {
-      setInfo("Farben gespeichert.");
+      setInfo(dict.designEditor.colorsSaved);
      router.refresh();
    }
    setBusy(false);
@@ -52,73 +66,78 @@ export default function DesignEditor() {
    setColors(DEFAULT_COLORS);
  }

-  async function uploadLogo(e: React.ChangeEvent<HTMLInputElement>) {
+  async function uploadAsset(kind: AssetKind, e: React.ChangeEvent<HTMLInputElement>) {
    const file = e.target.files?.[0];
    e.target.value = "";
    if (!file) return;
    if (!/^image\//.test(file.type)) {
-      setError("Bitte eine Bilddatei auswählen (PNG, JPG, SVG, WebP).");
+      setError(dict.designEditor.invalidImage);
      return;
    }
    setBusy(true);
    setError(null);
    setInfo(null);

-    const ext = file.name.split(".").pop()?.toLowerCase() ?? "png";
-    const path = `logo-${Date.now()}.${ext}`;
-    const { error: uploadError } = await supabase.storage
-      .from("branding")
-      .upload(path, file, { contentType: file.type });
-    if (uploadError) {
-      setError(`Upload fehlgeschlagen: ${uploadError.message}`);
+    const formData = new FormData();
+    formData.append("kind", kind);
+    formData.append("file", file);
+    const res = await fetch("/api/admin/branding", { method: "POST", body: formData });
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      setError(
+        formatMessage(dict.designEditor.uploadError, {
+          message: data.error ?? String(res.status),
+        })
+      );
      setBusy(false);
      return;
    }
+    const { path } = await res.json();

-    const oldPath = logoPath;
-    const { error: settingsError } = await supabase
-      .from("settings")
-      .update({ logo_path: path })
-      .eq("id", 1);
-    if (settingsError) {
-      setError(`Speichern fehlgeschlagen: ${settingsError.message}`);
-      setBusy(false);
-      return;
-    }
-    if (oldPath) {
-      await supabase.storage.from("branding").remove([oldPath]);
-    }
-    setLogoPath(path);
-    setInfo("Logo aktualisiert.");
+    if (kind === "logo") setLogoPath(path);
+    else setFaviconPath(path);
+    setInfo(kind === "logo" ? dict.designEditor.logoUpdated : dict.designEditor.faviconUpdated);
    router.refresh();
    setBusy(false);
  }

-  async function removeLogo() {
-    if (!logoPath) return;
-    if (!window.confirm("Logo wirklich entfernen?")) return;
+  async function removeAsset(kind: AssetKind) {
+    const path = kind === "logo" ? logoPath : faviconPath;
+    if (!path) return;
+    if (
+      !window.confirm(
+        kind === "logo"
+          ? dict.designEditor.confirmRemoveLogo
+          : dict.designEditor.confirmRemoveFavicon
+      )
+    )
+      return;
    setBusy(true);
    setError(null);
-    const { error } = await supabase
-      .from("settings")
-      .update({ logo_path: null })
-      .eq("id", 1);
-    if (error) {
-      setError(`Speichern fehlgeschlagen: ${error.message}`);
+    const res = await fetch("/api/admin/branding", {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ kind }),
+    });
+    if (!res.ok) {
+      setError(formatMessage(dict.designEditor.saveError, { message: String(res.status) }));
    } else {
-      await supabase.storage.from("branding").remove([logoPath]);
-      setLogoPath(null);
-      setInfo("Logo entfernt.");
+      if (kind === "logo") setLogoPath(null);
+      else setFaviconPath(null);
+      setInfo(kind === "logo" ? dict.designEditor.logoRemoved : dict.designEditor.faviconRemoved);
      router.refresh();
    }
    setBusy(false);
  }

  const currentLogo = logoUrl(logoPath);
+  const currentFavicon = faviconUrl(faviconPath);

  return (
    <div className="max-w-3xl space-y-6">
-      <h1 className="text-xl font-bold text-[var(--c-primary)]">Design</h1>
+      <h1 className="text-xl font-bold text-[var(--c-primary)]">
+        {dict.designEditor.title}
+      </h1>

      {error && (
        <p className="text-sm text-[var(--c-del)]" role="alert">
@@ -128,28 +147,26 @@ export default function DesignEditor() {
      {info && <p className="text-sm text-green-700">{info}</p>}

      <section className="card">
-        <h2 className="font-semibold mb-3">Logo</h2>
-        <p className="text-sm text-gray-600 mb-3">
-          Das Logo wird zentriert über der Speisekarte angezeigt.
-        </p>
+        <h2 className="font-semibold mb-3">{dict.designEditor.logoTitle}</h2>
+        <p className="text-sm text-gray-600 mb-3">{dict.designEditor.logoHint}</p>
        {currentLogo ? (
          // eslint-disable-next-line @next/next/no-img-element
          <img
            src={currentLogo}
-            alt="Aktuelles Logo"
+            alt="Logo"
            className="h-20 object-contain mb-3 border border-gray-200 rounded p-2"
          />
        ) : (
-          <p className="text-sm text-gray-400 mb-3">Kein Logo hinterlegt.</p>
+          <p className="text-sm text-gray-400 mb-3">{dict.designEditor.logoNone}</p>
        )}
        <div className="flex gap-2 items-center">
          <label className="btn btn-primary cursor-pointer">
-            Logo hochladen
+            {dict.designEditor.logoUpload}
            <input
              type="file"
-              accept="image/*"
+              accept="image/png,image/jpeg,image/webp,image/gif,image/x-icon"
              className="hidden"
-              onChange={uploadLogo}
+              onChange={(e) => uploadAsset("logo", e)}
              disabled={busy}
            />
          </label>
@@ -157,19 +174,56 @@ export default function DesignEditor() {
            <button
              type="button"
              className="btn btn-del"
-              onClick={removeLogo}
+              onClick={() => removeAsset("logo")}
              disabled={busy}
            >
-              Logo entfernen
+              {dict.designEditor.logoRemove}
            </button>
          )}
        </div>
      </section>

      <section className="card">
-        <h2 className="font-semibold mb-3">Farbgebung</h2>
+        <h2 className="font-semibold mb-3">{dict.designEditor.faviconTitle}</h2>
+        <p className="text-sm text-gray-600 mb-3">{dict.designEditor.faviconHint}</p>
+        {currentFavicon ? (
+          // eslint-disable-next-line @next/next/no-img-element
+          <img
+            src={currentFavicon}
+            alt="Favicon"
+            className="h-10 w-10 object-contain mb-3 border border-gray-200 rounded p-1"
+          />
+        ) : (
+          <p className="text-sm text-gray-400 mb-3">{dict.designEditor.faviconNone}</p>
+        )}
+        <div className="flex gap-2 items-center">
+          <label className="btn btn-primary cursor-pointer">
+            {dict.designEditor.faviconUpload}
+            <input
+              type="file"
+              accept="image/png,image/jpeg,image/webp,image/gif,image/x-icon"
+              className="hidden"
+              onChange={(e) => uploadAsset("favicon", e)}
+              disabled={busy}
+            />
+          </label>
+          {currentFavicon && (
+            <button
+              type="button"
+              className="btn btn-del"
+              onClick={() => removeAsset("favicon")}
+              disabled={busy}
+            >
+              {dict.designEditor.faviconRemove}
+            </button>
+          )}
+        </div>
+      </section>
+
+      <section className="card">
+        <h2 className="font-semibold mb-3">{dict.designEditor.colorsTitle}</h2>
        <div className="grid gap-3 sm:grid-cols-2">
-          {Object.entries(COLOR_LABELS).map(([key, label]) => (
+          {Object.entries(colorLabels).map(([key, label]) => (
            <label key={key} className="flex items-center gap-3 text-sm">
              <input
                type="color"
@@ -190,7 +244,7 @@ export default function DesignEditor() {
            onClick={saveColors}
            disabled={busy}
          >
-            Farben speichern
+            {dict.designEditor.colorsSave}
          </button>
          <button
            type="button"
@@ -198,7 +252,7 @@ export default function DesignEditor() {
            onClick={resetColors}
            disabled={busy}
          >
-            Auf Standard zurücksetzen
+            {dict.designEditor.colorsReset}
          </button>
        </div>
      </section>
@@ -1,27 +1,54 @@
 "use client";

 import { useCallback, useEffect, useMemo, useState } from "react";
-import { createClient } from "@/lib/supabase/client";
-import { formatPrice } from "@/lib/menu";
-import type { Dish } from "@/lib/types";
+import { dishCodes, formatPrice } from "@/lib/menu";
+import { formatMessage } from "@/lib/i18n/shared";
+import { localized } from "@/lib/types";
+import type { CodeItem, Dish } from "@/lib/types";
+import ChipPicker from "@/components/ChipPicker";
+import { useDict, useLanguages, useLocale } from "@/components/i18n/LocaleProvider";

 interface DishForm {
  id: string | null; // null = neues Gericht
  name: string;
+  translations: Record<string, string>;
  price: string;
+  allergens: string[];
+  additives: string[];
 }

-const EMPTY_FORM: DishForm = { id: null, name: "", price: "" };
+const EMPTY_FORM: DishForm = {
+  id: null,
+  name: "",
+  translations: {},
+  price: "",
+  allergens: [],
+  additives: [],
+};

-export default function DishManager() {
-  const supabase = useMemo(() => createClient(), []);
+export default function DishManager({
+  translateEnabled,
+}: {
+  translateEnabled: boolean;
+}) {
+  const dict = useDict();
+  const locale = useLocale();
+  const languages = useLanguages().filter((l) => l.code !== "de");
  const [dishes, setDishes] = useState<Dish[]>([]);
+  const [allergens, setAllergens] = useState<CodeItem[]>([]);
+  const [additives, setAdditives] = useState<CodeItem[]>([]);
  const [form, setForm] = useState<DishForm | null>(null);
  const [error, setError] = useState<string | null>(null);
+  const [notice, setNotice] = useState<string | null>(null);
+  const [ioBusy, setIoBusy] = useState(false);
  const [loading, setLoading] = useState(true);
  const [selected, setSelected] = useState<Set<string>>(new Set());
  const [bulkBusy, setBulkBusy] = useState(false);
  const [search, setSearch] = useState("");
+  const [labelingDetailed, setLabelingDetailed] = useState(true);
+  const [translateState, setTranslateState] = useState<"idle" | "busy" | "done">(
+    "idle"
+  );

  // Live-Suche: filtert die Liste bereits während des Tippens
  const visible = useMemo(() => {
@@ -30,14 +57,25 @@ export default function DishManager() {
  }, [dishes, search]);

  const load = useCallback(async () => {
-    const { data, error } = await supabase
-      .from("dishes")
-      .select("*")
-      .order("name");
-    if (error) setError(`Laden fehlgeschlagen: ${error.message}`);
-    else setDishes(data as Dish[]);
+    const [dishesRes, allergensRes, additivesRes, settingsRes] = await Promise.all([
+      fetch("/api/dishes"),
+      fetch("/api/allergens"),
+      fetch("/api/additives"),
+      fetch("/api/settings"),
+    ]);
+    if (!dishesRes.ok || !allergensRes.ok || !additivesRes.ok) {
+      setError(formatMessage(dict.dishManager.loadError, { message: "load failed" }));
+    } else {
+      setDishes(await dishesRes.json());
+      setAllergens(await allergensRes.json());
+      setAdditives(await additivesRes.json());
+    }
+    if (settingsRes.ok) {
+      const settings = await settingsRes.json();
+      setLabelingDetailed((settings?.labeling_mode ?? "detailed") !== "notice");
+    }
    setLoading(false);
-  }, [supabase]);
+  }, [dict]);

  useEffect(() => {
    load();
@@ -49,15 +87,29 @@ export default function DishManager() {
    setError(null);
    const price = Number.parseFloat(form.price.replace(",", "."));
    if (Number.isNaN(price) || price < 0) {
-      setError("Bitte einen gültigen Preis angeben, z. B. 3,50");
+      setError(dict.dishManager.invalidPrice);
      return;
    }
-    const payload = { name: form.name.trim(), price };
-    const { error } = form.id
-      ? await supabase.from("dishes").update(payload).eq("id", form.id)
-      : await supabase.from("dishes").insert(payload);
-    if (error) {
-      setError(`Speichern fehlgeschlagen: ${error.message}`);
+    const payload = {
+      name: form.name.trim(),
+      price,
+      allergens: form.allergens,
+      additives: form.additives,
+      translations: form.translations,
+    };
+    const res = form.id
+      ? await fetch(`/api/dishes/${form.id}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+        })
+      : await fetch("/api/dishes", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+        });
+    if (!res.ok) {
+      setError(formatMessage(dict.dishManager.saveError, { message: String(res.status) }));
      return;
    }
    setForm(null);
@@ -67,12 +119,13 @@ export default function DishManager() {
  async function remove(dish: Dish) {
    if (
      !window.confirm(
-        `„${dish.name}“ wirklich löschen? Das Gericht wird auch aus allen Wochenplänen entfernt.`
+        formatMessage(dict.dishManager.confirmDelete, { name: dish.name })
      )
    )
      return;
-    const { error } = await supabase.from("dishes").delete().eq("id", dish.id);
-    if (error) setError(`Löschen fehlgeschlagen: ${error.message}`);
+    const res = await fetch(`/api/dishes/${dish.id}`, { method: "DELETE" });
+    if (!res.ok)
+      setError(formatMessage(dict.dishManager.deleteError, { message: String(res.status) }));
    setSelected((prev) => {
      const next = new Set(prev);
      next.delete(dish.id);
@@ -106,37 +159,157 @@ export default function DishManager() {
    if (selected.size === 0) return;
    if (
      !window.confirm(
-        `${selected.size} Gericht(e) wirklich löschen? Sie werden auch aus allen Wochenplänen entfernt.`
+        formatMessage(dict.dishManager.confirmDeleteSelected, {
+          count: selected.size,
+        })
      )
    )
      return;
    setBulkBusy(true);
    setError(null);
-    const { error } = await supabase
-      .from("dishes")
-      .delete()
-      .in("id", Array.from(selected));
-    if (error) setError(`Löschen fehlgeschlagen: ${error.message}`);
+    const res = await fetch("/api/dishes/bulk-delete", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ids: Array.from(selected) }),
+    });
+    if (!res.ok)
+      setError(formatMessage(dict.dishManager.deleteError, { message: String(res.status) }));
    setSelected(new Set());
    setBulkBusy(false);
    await load();
  }

+  function toggleAllergen(code: string) {
+    if (!form) return;
+    setForm({
+      ...form,
+      allergens: form.allergens.includes(code)
+        ? form.allergens.filter((c) => c !== code)
+        : [...form.allergens, code],
+    });
+  }
+
+  function toggleAdditive(code: string) {
+    if (!form) return;
+    setForm({
+      ...form,
+      additives: form.additives.includes(code)
+        ? form.additives.filter((c) => c !== code)
+        : [...form.additives, code],
+    });
+  }
+
+  async function autoTranslate() {
+    if (!form || !form.name.trim()) return;
+    setTranslateState("busy");
+    setError(null);
+    try {
+      const res = await fetch("/api/translate", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          table: "dishes",
+          id: form.id,
+          text: form.name.trim(),
+        }),
+      });
+      const data = await res.json();
+      if (!res.ok) throw new Error(data?.error ?? `Fehler (${res.status})`);
+      setForm((prev) =>
+        prev
+          ? { ...prev, translations: { ...prev.translations, ...(data.translations ?? {}) } }
+          : prev
+      );
+      setTranslateState("done");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      setTranslateState("idle");
+    }
+  }
+
+  async function exportDishes() {
+    setError(null);
+    setNotice(null);
+    const res = await fetch("/api/dishes/export");
+    if (!res.ok) {
+      setError(formatMessage(dict.dishManager.exportError, { message: String(res.status) }));
+      return;
+    }
+    const blob = await res.blob();
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = "gerichte.csv";
+    a.click();
+    URL.revokeObjectURL(url);
+  }
+
+  async function importDishes(e: React.ChangeEvent<HTMLInputElement>) {
+    const file = e.target.files?.[0];
+    e.target.value = "";
+    if (!file) return;
+    setError(null);
+    setNotice(null);
+    setIoBusy(true);
+    const fd = new FormData();
+    fd.append("file", file);
+    const res = await fetch("/api/dishes/import", { method: "POST", body: fd });
+    setIoBusy(false);
+    if (!res.ok) {
+      setError(formatMessage(dict.dishManager.importError, { message: String(res.status) }));
+      return;
+    }
+    const data = (await res.json()) as {
+      created: number;
+      updated: number;
+      skipped: { row: number; reason: string }[];
+    };
+    let msg = formatMessage(dict.dishManager.importSuccess, {
+      created: data.created,
+      updated: data.updated,
+    });
+    if (data.skipped.length > 0) {
+      const reasons = data.skipped
+        .map((s) => formatMessage(dict.dishManager.importSkippedRow, s))
+        .join("; ");
+      msg +=
+        " " + formatMessage(dict.dishManager.importSkipped, { count: data.skipped.length, reasons });
+    }
+    setNotice(msg);
+    await load();
+  }
+
  const allSelected =
    visible.length > 0 && visible.every((d) => selected.has(d.id));

  return (
    <div className="max-w-3xl">
-      <div className="flex items-center gap-3 mb-4">
+      <div className="flex flex-wrap items-center gap-3 mb-4">
        <h1 className="text-xl font-bold text-[var(--c-primary)] mr-auto">
-          Gerichte
+          {dict.dishManager.title}
        </h1>
+        <button type="button" className="btn btn-neutral" onClick={exportDishes}>
+          {dict.dishManager.exportButton}
+        </button>
+        <label className="btn btn-neutral cursor-pointer">
+          {dict.dishManager.importButton}
+          <input
+            type="file"
+            accept=".csv,text/csv"
+            className="hidden"
+            onChange={importDishes}
+            disabled={ioBusy}
+          />
+        </label>
        <button
          type="button"
          className="btn btn-add"
-          onClick={() => setForm(EMPTY_FORM)}
+          onClick={() => {
+            setForm(EMPTY_FORM);
+            setTranslateState("idle");
+          }}
        >
-          Neues Gericht
+          {dict.dishManager.newDish}
        </button>
      </div>

@@ -145,15 +318,16 @@ export default function DishManager() {
          {error}
        </p>
      )}
+      {notice && <p className="mb-3 text-sm text-green-700">{notice}</p>}

      {form && (
-        <form onSubmit={save} className="card mb-4 space-y-3">
+        <form onSubmit={save} className="card mb-4 space-y-4">
          <h2 className="font-semibold">
-            {form.id ? "Gericht bearbeiten" : "Neues Gericht"}
+            {form.id ? dict.dishManager.editDish : dict.dishManager.newDish}
          </h2>
          <div>
            <label className="label" htmlFor="dish-name">
-              Bezeichnung
+              {dict.dishManager.nameLabel}
            </label>
            <input
              id="dish-name"
@@ -165,59 +339,120 @@ export default function DishManager() {
          </div>
          <div className="max-w-40">
            <label className="label" htmlFor="dish-price">
-              Preis in €
+              {dict.dishManager.priceLabel}
            </label>
            <input
              id="dish-price"
              className="input"
              inputMode="decimal"
-              placeholder="3,50"
+              placeholder={dict.dishManager.pricePlaceholder}
              value={form.price}
              onChange={(e) => setForm({ ...form, price: e.target.value })}
              required
            />
          </div>
+
+          {languages.length > 0 && (
+            <div className="grid gap-3 sm:grid-cols-2">
+              {languages.map((lang) => (
+                <div key={lang.code}>
+                  <label className="label" htmlFor={`dish-name-${lang.code}`}>
+                    {lang.label}
+                  </label>
+                  <input
+                    id={`dish-name-${lang.code}`}
+                    className="input"
+                    value={form.translations[lang.code] ?? ""}
+                    onChange={(e) =>
+                      setForm({
+                        ...form,
+                        translations: { ...form.translations, [lang.code]: e.target.value },
+                      })
+                    }
+                  />
+                </div>
+              ))}
+            </div>
+          )}
+          {translateEnabled && languages.length > 0 && (
+            <div>
+              <button
+                type="button"
+                className="btn btn-neutral"
+                onClick={autoTranslate}
+                disabled={translateState === "busy" || !form.name.trim()}
+              >
+                {translateState === "busy"
+                  ? dict.dishManager.translating
+                  : dict.dishManager.autoTranslate}
+              </button>
+              {translateState === "done" && (
+                <span className="ml-2 text-sm text-green-700">
+                  {dict.dishManager.translated}
+                </span>
+              )}
+            </div>
+          )}
+
+          {labelingDetailed ? (
+            <>
+              <ChipPicker
+                label={dict.codeList.allergensTitle}
+                items={allergens}
+                selected={form.allergens}
+                onToggle={toggleAllergen}
+              />
+              <ChipPicker
+                label={dict.codeList.additivesTitle}
+                items={additives}
+                selected={form.additives}
+                onToggle={toggleAdditive}
+              />
+            </>
+          ) : (
+            <p className="text-sm text-gray-500">{dict.dishManager.labelingDisabledHint}</p>
+          )}
          <div className="flex gap-2">
            <button type="submit" className="btn btn-add">
-              Speichern
+              {dict.common.save}
            </button>
            <button
              type="button"
              className="btn btn-neutral"
              onClick={() => setForm(null)}
            >
-              Abbrechen
+              {dict.common.cancel}
            </button>
          </div>
        </form>
      )}

      {loading ? (
-        <p className="text-gray-500">Lade Gerichte…</p>
+        <p className="text-gray-500">{dict.common.loading}</p>
      ) : (
        <>
          {dishes.length > 0 && (
            <input
              type="search"
              className="input mb-3"
-              placeholder="Gericht suchen…"
+              placeholder={dict.dishManager.searchPlaceholder}
              value={search}
              onChange={(e) => setSearch(e.target.value)}
-              aria-label="Gerichte durchsuchen"
+              aria-label={dict.dishManager.searchPlaceholder}
            />
          )}
          {dishes.length > 0 && (
-            <div className="flex items-center gap-3 mb-2 text-sm">
+            <div className="flex flex-wrap items-center gap-3 mb-2 text-sm">
              <label className="flex items-center gap-2 cursor-pointer">
                <input
                  type="checkbox"
                  checked={allSelected}
                  onChange={toggleAll}
                />
-                Alle auswählen
+                {dict.dishManager.selectAll}
              </label>
              <span className="text-gray-500">
-                {selected.size} ausgewählt
+                {formatMessage(dict.dishManager.selectedCount, { count: selected.size })}
              </span>
              <button
                type="button"
@@ -225,53 +460,65 @@ export default function DishManager() {
                onClick={removeSelected}
                disabled={selected.size === 0 || bulkBusy}
              >
-                Ausgewählte löschen{selected.size > 0 ? ` (${selected.size})` : ""}
+                {selected.size > 0
+                  ? formatMessage(dict.dishManager.deleteSelectedCount, {
+                      count: selected.size,
+                    })
+                  : dict.dishManager.deleteSelected}
              </button>
            </div>
          )}
          <ul className="divide-y divide-gray-200 border border-gray-200 rounded-md bg-white">
-            {visible.map((dish) => (
-              <li key={dish.id} className="flex items-center gap-3 px-4 py-2">
+            {visible.map((dish) => {
+              const codes = dishCodes(dish);
+              return (
+                <li key={dish.id} className="flex flex-wrap items-center gap-3 px-4 py-2">
                  <input
                    type="checkbox"
                    checked={selected.has(dish.id)}
                    onChange={() => toggleOne(dish.id)}
-                  aria-label={`${dish.name} auswählen`}
+                    aria-label={dish.name}
                  />
                  <span className="mr-auto">
-                  <span className="font-semibold">{dish.name}</span>{" "}
-                  <span className="text-gray-500">– {formatPrice(dish.price)}</span>
+                    <span className="font-semibold">{localized(dish, locale)}</span>
+                    {codes && <sup className="dish-codes">{codes}</sup>}{" "}
+                    <span className="text-gray-500">
+                      – {formatPrice(dish.price)}
+                    </span>
                  </span>
                  <button
                    type="button"
                    className="btn btn-primary"
-                  onClick={() =>
+                    onClick={() => {
                      setForm({
                        id: dish.id,
                        name: dish.name,
+                        translations: { ...dish.translations },
                        price: String(dish.price).replace(".", ","),
-                    })
-                  }
+                        allergens: dish.allergens ?? [],
+                        additives: dish.additives ?? [],
+                      });
+                      setTranslateState("idle");
+                    }}
                  >
-                  Bearbeiten
+                    {dict.common.edit}
                  </button>
                  <button
                    type="button"
                    className="btn btn-del"
                    onClick={() => remove(dish)}
                  >
-                  Löschen
+                    {dict.common.delete}
                  </button>
                </li>
-            ))}
+              );
+            })}
            {dishes.length === 0 && (
-              <li className="px-4 py-3 text-gray-500">
-                Noch keine Gerichte angelegt.
-              </li>
+              <li className="px-4 py-3 text-gray-500">{dict.dishManager.empty}</li>
            )}
            {dishes.length > 0 && visible.length === 0 && (
              <li className="px-4 py-3 text-gray-500">
-                Keine Treffer für „{search}“.
+                {formatMessage(dict.dishManager.noResults, { query: search })}
              </li>
            )}
          </ul>
@@ -0,0 +1,142 @@
+"use client";
+
+// Umschaltung zwischen der detaillierten Allergen-/Zusatzstoff-Auswahl
+// je Gericht und einem einfachen, editierbaren Hinweistext.
+
+import { useCallback, useEffect, useState } from "react";
+import { formatMessage } from "@/lib/i18n/shared";
+import { useDict } from "@/components/i18n/LocaleProvider";
+import type { LabelingMode } from "@/lib/db/settings";
+
+export default function LabelingNoticeEditor() {
+  const dict = useDict();
+  const [mode, setMode] = useState<LabelingMode>("detailed");
+  const [noticeDe, setNoticeDe] = useState("");
+  const [noticeEn, setNoticeEn] = useState("");
+  const [noticePl, setNoticePl] = useState("");
+  const [loading, setLoading] = useState(true);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [info, setInfo] = useState<string | null>(null);
+
+  const load = useCallback(async () => {
+    const res = await fetch("/api/settings");
+    if (!res.ok) {
+      setError(formatMessage(dict.labelingNotice.loadError, { message: String(res.status) }));
+      setLoading(false);
+      return;
+    }
+    const data = await res.json();
+    setMode(data.labeling_mode ?? "detailed");
+    setNoticeDe(data.labeling_notice ?? "");
+    setNoticeEn(data.labeling_notice_en ?? "");
+    setNoticePl(data.labeling_notice_pl ?? "");
+    setLoading(false);
+  }, [dict]);
+
+  useEffect(() => {
+    load();
+  }, [load]);
+
+  async function save() {
+    setBusy(true);
+    setError(null);
+    setInfo(null);
+    const res = await fetch("/api/settings", {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        labeling_mode: mode,
+        labeling_notice: noticeDe.trim(),
+        labeling_notice_en: noticeEn.trim() || null,
+        labeling_notice_pl: noticePl.trim() || null,
+      }),
+    });
+    setBusy(false);
+    if (!res.ok) {
+      setError(formatMessage(dict.labelingNotice.saveError, { message: String(res.status) }));
+      return;
+    }
+    setInfo(dict.labelingNotice.saved);
+  }
+
+  if (loading) return null;
+
+  return (
+    <section className="card">
+      <h2 className="font-semibold mb-2">{dict.labelingNotice.title}</h2>
+      <p className="text-sm text-gray-600 mb-3">{dict.labelingNotice.hint}</p>
+
+      {error && (
+        <p className="mb-3 text-sm text-[var(--c-del)]" role="alert">
+          {error}
+        </p>
+      )}
+      {info && <p className="mb-3 text-sm text-green-700">{info}</p>}
+
+      <div className="flex flex-col gap-2 mb-4">
+        <label className="flex items-center gap-2 cursor-pointer">
+          <input
+            type="radio"
+            name="labeling-mode"
+            checked={mode === "detailed"}
+            onChange={() => setMode("detailed")}
+          />
+          {dict.labelingNotice.modeDetailed}
+        </label>
+        <label className="flex items-center gap-2 cursor-pointer">
+          <input
+            type="radio"
+            name="labeling-mode"
+            checked={mode === "notice"}
+            onChange={() => setMode("notice")}
+          />
+          {dict.labelingNotice.modeNotice}
+        </label>
+      </div>
+
+      <div className="space-y-3 mb-4">
+        <div>
+          <label className="label" htmlFor="labeling-notice-de">
+            {dict.labelingNotice.noticeDeLabel}
+          </label>
+          <textarea
+            id="labeling-notice-de"
+            className="input"
+            rows={2}
+            value={noticeDe}
+            onChange={(e) => setNoticeDe(e.target.value)}
+          />
+        </div>
+        <div>
+          <label className="label" htmlFor="labeling-notice-en">
+            {dict.labelingNotice.noticeEnLabel}
+          </label>
+          <textarea
+            id="labeling-notice-en"
+            className="input"
+            rows={2}
+            value={noticeEn}
+            onChange={(e) => setNoticeEn(e.target.value)}
+          />
+        </div>
+        <div>
+          <label className="label" htmlFor="labeling-notice-pl">
+            {dict.labelingNotice.noticePlLabel}
+          </label>
+          <textarea
+            id="labeling-notice-pl"
+            className="input"
+            rows={2}
+            value={noticePl}
+            onChange={(e) => setNoticePl(e.target.value)}
+          />
+        </div>
+      </div>
+
+      <button type="button" className="btn btn-add" onClick={save} disabled={busy}>
+        {dict.labelingNotice.save}
+      </button>
+    </section>
+  );
+}
@@ -0,0 +1,293 @@
+"use client";
+
+// Verwaltung der Sprachpakete (nur Admin): Sprachen aktivieren/
+// deaktivieren (bis auf eine einzige reduzierbar), Vorlage der
+// aktuellen Begriffe herunterladen, Übersetzungsdatei hochladen, neue
+// Sprache anlegen/löschen. Deutsch ist die feste Basis-Sprache und
+// nicht löschbar.
+
+import { useCallback, useEffect, useState } from "react";
+import { formatMessage } from "@/lib/i18n/shared";
+import { useDict } from "@/components/i18n/LocaleProvider";
+
+interface LanguageItem {
+  code: string;
+  label: string;
+  is_base: boolean;
+  active: boolean;
+  percent: number;
+  outdated: boolean;
+  missingCount: number;
+}
+
+export default function LanguageManager() {
+  const dict = useDict();
+  const [languages, setLanguages] = useState<LanguageItem[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [notice, setNotice] = useState<string | null>(null);
+  const [busy, setBusy] = useState(false);
+  const [newCode, setNewCode] = useState("");
+  const [newLabel, setNewLabel] = useState("");
+
+  const load = useCallback(async () => {
+    const res = await fetch("/api/admin/languages");
+    if (!res.ok) {
+      setError(formatMessage(dict.languageManager.loadError, { message: String(res.status) }));
+    } else {
+      setLanguages(await res.json());
+    }
+    setLoading(false);
+  }, [dict]);
+
+  useEffect(() => {
+    load();
+  }, [load]);
+
+  async function toggleActive(item: LanguageItem) {
+    setError(null);
+    setNotice(null);
+    setBusy(true);
+    const res = await fetch(`/api/admin/languages/${item.code}`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ active: !item.active }),
+    });
+    setBusy(false);
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      setError(
+        data.error === "cannot_deactivate_last"
+          ? dict.languageManager.cannotDeactivateLast
+          : formatMessage(dict.languageManager.saveError, { message: data.error ?? String(res.status) })
+      );
+      return;
+    }
+    await load();
+  }
+
+  async function deleteLanguage(item: LanguageItem) {
+    if (!window.confirm(formatMessage(dict.languageManager.confirmDelete, { label: item.label })))
+      return;
+    setError(null);
+    setNotice(null);
+    setBusy(true);
+    const res = await fetch(`/api/admin/languages/${item.code}`, { method: "DELETE" });
+    setBusy(false);
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      setError(
+        data.error === "cannot_delete_base"
+          ? dict.languageManager.cannotDeleteBase
+          : formatMessage(dict.languageManager.deleteError, { message: data.error ?? String(res.status) })
+      );
+      return;
+    }
+    await load();
+  }
+
+  async function downloadTemplate() {
+    setError(null);
+    const res = await fetch("/api/admin/languages/template");
+    if (!res.ok) {
+      setError(formatMessage(dict.languageManager.loadError, { message: String(res.status) }));
+      return;
+    }
+    const blob = await res.blob();
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = "sprachvorlage.json";
+    a.click();
+    URL.revokeObjectURL(url);
+  }
+
+  async function uploadImport(code: string, e: React.ChangeEvent<HTMLInputElement>) {
+    const file = e.target.files?.[0];
+    e.target.value = "";
+    if (!file) return;
+    setError(null);
+    setNotice(null);
+    setBusy(true);
+    const fd = new FormData();
+    fd.append("file", file);
+    const res = await fetch(`/api/admin/languages/${code}/import`, {
+      method: "POST",
+      body: fd,
+    });
+    setBusy(false);
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      setError(formatMessage(dict.languageManager.importError, { message: data.error ?? String(res.status) }));
+      return;
+    }
+    const data = (await res.json()) as {
+      imported: number;
+      skipped: { key: string; reason: string }[];
+    };
+    let msg = formatMessage(dict.languageManager.importSuccess, { count: data.imported });
+    if (data.skipped.length > 0) {
+      const first = data.skipped[0];
+      const [reason, placeholder] = first.reason.split(":");
+      if (reason === "missing_placeholder") {
+        msg +=
+          " " +
+          formatMessage(dict.languageManager.importMissingPlaceholder, {
+            key: first.key,
+            placeholder: `{${placeholder}}`,
+          });
+        if (data.skipped.length > 1) msg += ` (+${data.skipped.length - 1})`;
+      }
+    }
+    setNotice(msg);
+    await load();
+  }
+
+  async function createLanguage(e: React.FormEvent) {
+    e.preventDefault();
+    setError(null);
+    setNotice(null);
+    const code = newCode.trim().toLowerCase();
+    const label = newLabel.trim();
+    if (!/^[a-z]{2,5}$/.test(code)) {
+      setError(dict.languageManager.invalidCode);
+      return;
+    }
+    if (!label) return;
+    setBusy(true);
+    const res = await fetch("/api/admin/languages", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code, label }),
+    });
+    setBusy(false);
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      setError(
+        data.error === "duplicate_code"
+          ? formatMessage(dict.languageManager.duplicateCode, { code })
+          : formatMessage(dict.languageManager.saveError, { message: data.error ?? String(res.status) })
+      );
+      return;
+    }
+    setNewCode("");
+    setNewLabel("");
+    await load();
+  }
+
+  return (
+    <div className="max-w-3xl space-y-6">
+      <div>
+        <h1 className="text-xl font-bold text-[var(--c-primary)] mb-1">
+          {dict.languageManager.title}
+        </h1>
+        <p className="text-sm text-gray-600">{dict.languageManager.hint}</p>
+      </div>
+
+      {error && (
+        <p className="text-sm text-[var(--c-del)]" role="alert">
+          {error}
+        </p>
+      )}
+      {notice && <p className="text-sm text-green-700">{notice}</p>}
+
+      <section className="card">
+        <div className="flex flex-wrap items-center gap-3 mb-3">
+          <h2 className="font-semibold mr-auto">{dict.languageManager.title}</h2>
+          <button type="button" className="btn btn-neutral" onClick={downloadTemplate}>
+            {dict.languageManager.downloadTemplate}
+          </button>
+        </div>
+
+        {loading ? (
+          <p className="text-gray-500">{dict.common.loading}</p>
+        ) : (
+          <ul className="divide-y divide-gray-100">
+            {languages.map((item) => (
+              <li key={item.code} className="flex flex-wrap items-center gap-3 py-2 text-sm">
+                <label className="flex items-center gap-2 cursor-pointer">
+                  <input
+                    type="checkbox"
+                    checked={item.active}
+                    onChange={() => toggleActive(item)}
+                    disabled={busy}
+                  />
+                  <span className="font-semibold uppercase">{item.code}</span>
+                </label>
+                <span className="mr-auto">
+                  {item.label}
+                  {item.is_base ? (
+                    <span className="ml-2 text-xs text-gray-500">
+                      ({dict.languageManager.baseBadge})
+                    </span>
+                  ) : (
+                    <span className="ml-2 text-xs text-gray-500">
+                      {item.outdated
+                        ? formatMessage(dict.languageManager.outdated, { count: item.missingCount })
+                        : formatMessage(dict.languageManager.completeness, { percent: item.percent })}
+                    </span>
+                  )}
+                </span>
+                {!item.is_base && (
+                  <>
+                    <label className="btn btn-neutral cursor-pointer">
+                      {dict.languageManager.uploadTranslation}
+                      <input
+                        type="file"
+                        accept=".json,application/json"
+                        className="hidden"
+                        onChange={(e) => uploadImport(item.code, e)}
+                        disabled={busy}
+                      />
+                    </label>
+                    <button
+                      type="button"
+                      className="btn btn-del"
+                      onClick={() => deleteLanguage(item)}
+                      disabled={busy}
+                    >
+                      {dict.languageManager.delete}
+                    </button>
+                  </>
+                )}
+              </li>
+            ))}
+          </ul>
+        )}
+      </section>
+
+      <section className="card">
+        <h2 className="font-semibold mb-3">{dict.languageManager.newLanguageTitle}</h2>
+        <form onSubmit={createLanguage} className="flex flex-wrap items-end gap-3">
+          <div className="max-w-40">
+            <label className="label" htmlFor="new-lang-code">
+              {dict.languageManager.newLanguageCodeLabel}
+            </label>
+            <input
+              id="new-lang-code"
+              className="input"
+              value={newCode}
+              onChange={(e) => setNewCode(e.target.value)}
+              required
+            />
+          </div>
+          <div>
+            <label className="label" htmlFor="new-lang-label">
+              {dict.languageManager.newLanguageLabelLabel}
+            </label>
+            <input
+              id="new-lang-label"
+              className="input"
+              value={newLabel}
+              onChange={(e) => setNewLabel(e.target.value)}
+              required
+            />
+          </div>
+          <button type="submit" className="btn btn-add" disabled={busy}>
+            {dict.languageManager.create}
+          </button>
+        </form>
+      </section>
+    </div>
+  );
+}
@@ -0,0 +1,162 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import Link from "next/link";
+import { startAuthentication } from "@simplewebauthn/browser";
+import { formatMessage } from "@/lib/i18n/shared";
+import { useDict } from "@/components/i18n/LocaleProvider";
+import LanguageSwitcher from "@/components/i18n/LanguageSwitcher";
+import type { Dict } from "@/lib/i18n/shared";
+
+function authErrorMessage(dict: Dict, code: string): string {
+  if (code === "invalid_credentials") return dict.login.errorInvalidCredentials;
+  if (code === "password_disabled") return dict.login.errorPasswordDisabled;
+  if (code === "oidc_invalid_state") return dict.login.errorOidcInvalidState;
+  if (code === "oidc_unknown_user") return dict.login.errorOidcUnknownUser;
+  if (code === "oidc_failed") return dict.login.errorOidcFailed;
+  if (/cancelled|aborted|NotAllowedError/i.test(code))
+    return dict.login.errorPasskeyCancelled;
+  return formatMessage(dict.login.errorGeneric, { message: code });
+}
+
+function redirectPath(role: string): string {
+  return role === "admin" ? "/admin" : "/intern";
+}
+
+export default function LoginForm({
+  oidcEnabled,
+  initialError,
+}: {
+  oidcEnabled: boolean;
+  initialError: string | null;
+}) {
+  const router = useRouter();
+  const dict = useDict();
+  const [email, setEmail] = useState("");
+  const [password, setPassword] = useState("");
+  const [error, setError] = useState<string | null>(() =>
+    initialError ? authErrorMessage(dict, initialError) : null
+  );
+  const [busy, setBusy] = useState(false);
+
+  async function signInWithPassword(e: React.FormEvent) {
+    e.preventDefault();
+    setError(null);
+    setBusy(true);
+    const res = await fetch("/api/auth/login", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, password }),
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      setError(authErrorMessage(dict, data.error ?? "unknown"));
+      setBusy(false);
+      return;
+    }
+    router.replace(redirectPath(data.role));
+    router.refresh();
+  }
+
+  async function signInWithPasskey() {
+    setError(null);
+    setBusy(true);
+    try {
+      const optionsRes = await fetch("/api/auth/passkeys/login-options", { method: "POST" });
+      const options = await optionsRes.json();
+      const response = await startAuthentication({ optionsJSON: options });
+
+      const verifyRes = await fetch("/api/auth/passkeys/login-verify", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ response }),
+      });
+      const data = await verifyRes.json().catch(() => ({}));
+      if (!verifyRes.ok) {
+        setError(authErrorMessage(dict, data.error ?? "unknown"));
+        setBusy(false);
+        return;
+      }
+      router.replace(redirectPath(data.role));
+      router.refresh();
+    } catch (err) {
+      setError(authErrorMessage(dict, err instanceof Error ? err.message : String(err)));
+      setBusy(false);
+    }
+  }
+
+  return (
+    <div className="flex-1 flex items-center justify-center p-4">
+      <div className="card w-full max-w-sm">
+        <div className="flex justify-between items-center mb-4">
+          <h1 className="text-xl font-bold text-[var(--c-primary)]">
+            {dict.login.title}
+          </h1>
+          <LanguageSwitcher variant="light" />
+        </div>
+        <form onSubmit={signInWithPassword} className="space-y-3">
+          <div>
+            <label className="label" htmlFor="email">
+              {dict.common.email}
+            </label>
+            <input
+              id="email"
+              type="email"
+              className="input"
+              value={email}
+              onChange={(e) => setEmail(e.target.value)}
+              autoComplete="username webauthn"
+              required
+            />
+          </div>
+          <div>
+            <label className="label" htmlFor="password">
+              {dict.common.password}
+            </label>
+            <input
+              id="password"
+              type="password"
+              className="input"
+              value={password}
+              onChange={(e) => setPassword(e.target.value)}
+              autoComplete="current-password"
+              required
+            />
+          </div>
+          {error && <p className="text-sm text-[var(--c-del)]">{error}</p>}
+          <button type="submit" className="btn btn-primary w-full" disabled={busy}>
+            {dict.login.submit}
+          </button>
+        </form>
+
+        <div className="my-4 flex items-center gap-3 text-xs text-gray-400">
+          <span className="h-px flex-1 bg-gray-200" />
+          {dict.login.or}
+          <span className="h-px flex-1 bg-gray-200" />
+        </div>
+
+        <button
+          type="button"
+          onClick={signInWithPasskey}
+          className="btn btn-neutral w-full"
+          disabled={busy}
+        >
+          {dict.login.passkeyButton}
+        </button>
+
+        {oidcEnabled && (
+          <a href="/api/auth/oidc/login" className="btn btn-neutral w-full mt-2">
+            {dict.login.ssoButton}
+          </a>
+        )}
+
+        <p className="mt-4 text-center text-sm">
+          <Link href="/" className="text-gray-500 hover:text-[var(--c-primary)]">
+            {dict.login.backToMenu}
+          </Link>
+        </p>
+      </div>
+    </div>
+  );
+}
@@ -1,27 +1,32 @@
 "use client";

-import { useCallback, useEffect, useMemo, useState } from "react";
-import { createClient } from "@/lib/supabase/client";
+import { useCallback, useEffect, useState } from "react";
+import { startRegistration } from "@simplewebauthn/browser";
+import { formatMessage } from "@/lib/i18n/shared";
+import { useDict } from "@/components/i18n/LocaleProvider";

 interface PasskeyItem {
  id: string;
-  friendly_name?: string;
+  name: string | null;
  created_at: string;
-  last_used_at?: string;
+  last_used_at: string | null;
 }

 export default function PasskeyManager() {
-  const supabase = useMemo(() => createClient(), []);
+  const dict = useDict();
  const [passkeys, setPasskeys] = useState<PasskeyItem[]>([]);
  const [error, setError] = useState<string | null>(null);
  const [info, setInfo] = useState<string | null>(null);
  const [busy, setBusy] = useState(false);

  const load = useCallback(async () => {
-    const { data, error } = await supabase.auth.passkey.list();
-    if (error) setError(`Passkeys konnten nicht geladen werden: ${error.message}`);
-    else setPasskeys((data ?? []) as PasskeyItem[]);
-  }, [supabase]);
+    const res = await fetch("/api/auth/passkeys");
+    if (!res.ok) {
+      setError(formatMessage(dict.passkeys.loadError, { message: String(res.status) }));
+      return;
+    }
+    setPasskeys(await res.json());
+  }, [dict]);

  useEffect(() => {
    load();
@@ -32,39 +37,46 @@ export default function PasskeyManager() {
    setInfo(null);
    setBusy(true);
    try {
-      const { error } = await supabase.auth.registerPasskey();
-      if (error) {
-        setError(`Registrierung fehlgeschlagen: ${error.message}`);
-      } else {
-        setInfo("Passkey wurde erfolgreich registriert.");
-        await load();
+      const optionsRes = await fetch("/api/auth/passkeys/register-options", { method: "POST" });
+      if (!optionsRes.ok) throw new Error(String(optionsRes.status));
+      const options = await optionsRes.json();
+      const response = await startRegistration({ optionsJSON: options });
+
+      const verifyRes = await fetch("/api/auth/passkeys/register-verify", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ response }),
+      });
+      if (!verifyRes.ok) {
+        const data = await verifyRes.json().catch(() => ({}));
+        throw new Error(data.error ?? String(verifyRes.status));
      }
+      setInfo(dict.passkeys.registered);
+      await load();
    } catch (err) {
      setError(
        /NotAllowedError|abort/i.test(String(err))
-          ? "Die Passkey-Registrierung wurde abgebrochen."
-          : `Registrierung fehlgeschlagen: ${err instanceof Error ? err.message : String(err)}`
+          ? dict.passkeys.registerCancelled
+          : formatMessage(dict.passkeys.registerError, {
+              message: err instanceof Error ? err.message : String(err),
+            })
      );
    }
    setBusy(false);
  }

  async function remove(pk: PasskeyItem) {
-    if (!window.confirm("Diesen Passkey wirklich löschen?")) return;
-    const { error } = await supabase.auth.passkey.delete({ passkeyId: pk.id });
-    if (error) setError(`Löschen fehlgeschlagen: ${error.message}`);
+    if (!window.confirm(dict.passkeys.confirmDelete)) return;
+    const res = await fetch(`/api/auth/passkeys/${pk.id}`, { method: "DELETE" });
+    if (!res.ok)
+      setError(formatMessage(dict.passkeys.deleteError, { message: String(res.status) }));
    await load();
  }

  return (
    <section className="card">
-      <h2 className="font-semibold mb-1">Passkeys</h2>
-      <p className="text-sm text-gray-600 mb-3">
-        Mit einem Passkey (Fingerabdruck, Gesichtserkennung oder
-        Sicherheitsschlüssel) kannst du dich künftig ohne Passwort anmelden.
-        Passkeys gelten pro Domain – für den Live-Betrieb muss die Domain in
-        der Supabase-Konfiguration hinterlegt sein.
-      </p>
+      <h2 className="font-semibold mb-1">{dict.passkeys.title}</h2>
+      <p className="text-sm text-gray-600 mb-3">{dict.passkeys.hint}</p>

      {error && (
        <p className="mb-2 text-sm text-[var(--c-del)]" role="alert">
@@ -79,19 +91,18 @@ export default function PasskeyManager() {
        onClick={register}
        disabled={busy}
      >
-        Neuen Passkey registrieren
+        {dict.passkeys.register}
      </button>

      <ul className="divide-y divide-gray-100">
        {passkeys.map((pk) => (
-          <li key={pk.id} className="flex items-center gap-3 py-1.5 text-sm">
+          <li key={pk.id} className="flex flex-wrap items-center gap-3 py-1.5 text-sm">
            <span className="mr-auto">
-              <span className="font-semibold">
-                {pk.friendly_name || "Passkey"}
-              </span>{" "}
+              <span className="font-semibold">{pk.name || "Passkey"}</span>{" "}
              <span className="text-gray-500">
-                – angelegt am{" "}
-                {new Date(pk.created_at).toLocaleDateString("de-DE")}
+                {formatMessage(dict.passkeys.createdOn, {
+                  date: new Date(pk.created_at).toLocaleDateString(dict.dateLocale),
+                })}
              </span>
            </span>
            <button
@@ -99,14 +110,12 @@ export default function PasskeyManager() {
              className="btn btn-del"
              onClick={() => remove(pk)}
            >
-              Löschen
+              {dict.common.delete}
            </button>
          </li>
        ))}
        {passkeys.length === 0 && (
-          <li className="py-2 text-gray-500 text-sm">
-            Noch keine Passkeys registriert.
-          </li>
+          <li className="py-2 text-gray-500 text-sm">{dict.passkeys.empty}</li>
        )}
      </ul>
    </section>
@@ -0,0 +1,197 @@
+"use client";
+
+// Mobile Ansicht der öffentlichen Speisekarte: Tag (Standard) oder Woche,
+// umschaltbar ohne Seiten-Reload. Ab dem "sm"-Breakpoint übernimmt die
+// normale Wochentabelle (siehe app/page.tsx), diese Komponente blendet
+// sich dort per CSS aus.
+
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+import {
+  addDays,
+  dishCodes,
+  entriesFor,
+  formatDateLong,
+  formatPrice,
+  mondayOf,
+  todayISO,
+  weekdayIndex,
+} from "@/lib/menu";
+import { localized } from "@/lib/types";
+import type { ClosedDay, MenuEntry, Section } from "@/lib/types";
+import { useDict, useLocale } from "@/components/i18n/LocaleProvider";
+import LanguageSwitcher from "@/components/i18n/LanguageSwitcher";
+
+export default function PublicMobileMenu({
+  monday,
+  sections,
+  entries,
+  closedDays,
+  showLabeling,
+}: {
+  monday: string;
+  sections: Section[];
+  entries: MenuEntry[];
+  closedDays: ClosedDay[];
+  showLabeling: boolean;
+}) {
+  const router = useRouter();
+  const dict = useDict();
+  const locale = useLocale();
+  const days = dict.weekdays.long.map((weekday, i) => ({
+    weekday,
+    short: dict.weekdays.short[i],
+    iso: addDays(monday, i),
+  }));
+  const isCurrentWeek = monday === mondayOf(todayISO());
+  const todayIdx = isCurrentWeek ? weekdayIndex(todayISO()) : -1;
+
+  const [tab, setTab] = useState<"tag" | "woche">("tag");
+  const [selectedIdx, setSelectedIdx] = useState(todayIdx >= 0 ? todayIdx : 0);
+
+  function goToday() {
+    const currentMonday = mondayOf(todayISO());
+    if (currentMonday === monday) {
+      const idx = weekdayIndex(todayISO());
+      setSelectedIdx(idx >= 0 ? idx : 0);
+      setTab("tag");
+    } else {
+      router.push(`/?woche=${currentMonday}`);
+    }
+  }
+
+  function renderDay(day: { weekday: string; iso: string }) {
+    const closed = closedDays.find((c) => c.closed_date === day.iso);
+    return (
+      <div key={day.iso} className="mb-4 last:mb-0">
+        <h3 className="font-bold text-[var(--c-primary)] mb-2">
+          {day.weekday} · {formatDateLong(day.iso, dict.dateLocale)}
+        </h3>
+        {closed ? (
+          <div className="rounded-md border border-red-200 bg-red-50 px-3 py-3 text-sm text-red-700 text-center">
+            <span aria-hidden>🔒</span>{" "}
+            <span className="font-semibold">{dict.publicMenu.closedLabel}</span>
+            {localized(closed, locale) && <span> – {localized(closed, locale)}</span>}
+          </div>
+        ) : (
+          <div className="space-y-3">
+            {sections.map((s) => {
+              const items = entriesFor(entries, day.iso, s.key);
+              return (
+                <div
+                  key={s.key}
+                  className="rounded-md border border-gray-200 overflow-hidden"
+                >
+                  <div className="bg-[var(--c-primary)] text-[var(--c-header-text)] px-3 py-1.5 text-sm">
+                    <span className="font-semibold">{localized(s, locale)}</span>{" "}
+                    <span className="opacity-80">· {s.time_range}</span>
+                  </div>
+                  <div className="bg-[var(--c-row-bg)] px-3 py-2 text-sm">
+                    {items.length === 0 ? (
+                      <p className="text-gray-500">{dict.publicMenu.noEntry}</p>
+                    ) : (
+                      items.map((e) => {
+                        const codes = dishCodes(e.dish);
+                        return (
+                          <p key={e.id} className="mb-1 last:mb-0">
+                            <span className="font-semibold">
+                              {localized(e.dish, locale)}
+                            </span>
+                            {showLabeling && codes && (
+                              <sup className="dish-codes">{codes}</sup>
+                            )}{" "}
+                            – {formatPrice(e.dish.price)}
+                          </p>
+                        );
+                      })
+                    )}
+                  </div>
+                </div>
+              );
+            })}
+          </div>
+        )}
+      </div>
+    );
+  }
+
+  return (
+    <div className="sm:hidden mb-6">
+      <div className="flex justify-end mb-3">
+        <LanguageSwitcher variant="light" />
+      </div>
+
+      <div className="flex gap-2 mb-3">
+        <Link
+          href={`/?woche=${addDays(monday, -7)}`}
+          className="btn btn-add flex-1 justify-center"
+        >
+          {dict.publicMenu.prevWeekShort}
+        </Link>
+        <button
+          type="button"
+          onClick={goToday}
+          className="btn btn-primary flex-1"
+        >
+          {dict.publicMenu.today}
+        </button>
+        <Link
+          href={`/?woche=${addDays(monday, 7)}`}
+          className="btn btn-add flex-1 justify-center"
+        >
+          {dict.publicMenu.nextWeekShort}
+        </Link>
+      </div>
+
+      <div className="flex gap-2 mb-3" role="tablist" aria-label="Ansicht">
+        <button
+          type="button"
+          role="tab"
+          aria-selected={tab === "tag"}
+          onClick={() => setTab("tag")}
+          className={`btn flex-1 ${tab === "tag" ? "btn-primary" : "btn-neutral"}`}
+        >
+          {dict.publicMenu.dayTab}
+        </button>
+        <button
+          type="button"
+          role="tab"
+          aria-selected={tab === "woche"}
+          onClick={() => setTab("woche")}
+          className={`btn flex-1 ${tab === "woche" ? "btn-primary" : "btn-neutral"}`}
+        >
+          {dict.publicMenu.weekTab}
+        </button>
+      </div>
+
+      {tab === "tag" ? (
+        <>
+          <div className="flex gap-1 mb-3">
+            {days.map((d, i) => (
+              <button
+                key={d.iso}
+                type="button"
+                onClick={() => setSelectedIdx(i)}
+                className={`flex-1 rounded-md py-1.5 text-sm font-semibold border transition-colors ${
+                  i === selectedIdx
+                    ? "bg-[var(--c-primary)] text-white border-[var(--c-primary)]"
+                    : "bg-white text-gray-600 border-gray-200"
+                } ${i === todayIdx ? "ring-2 ring-[var(--c-accent)] ring-offset-1" : ""}`}
+              >
+                {d.short}
+              </button>
+            ))}
+          </div>
+          {renderDay(days[selectedIdx])}
+        </>
+      ) : (
+        <div>{days.map((d) => renderDay(d))}</div>
+      )}
+
+      <Link href="/vorschlag" className="btn btn-neutral w-full justify-center mt-2">
+        {dict.publicMenu.suggestDish}
+      </Link>
+    </div>
+  );
+}
@@ -0,0 +1,290 @@
+"use client";
+
+// Verwaltung der Essenszeiten (Brotzeit, Mittagessen, …):
+// anlegen, umbenennen, Uhrzeit ändern, löschen, Reihenfolge anpassen.
+
+import { useCallback, useEffect, useState } from "react";
+import { formatMessage } from "@/lib/i18n/shared";
+import { localized } from "@/lib/types";
+import type { Section } from "@/lib/types";
+import { useDict, useLanguages, useLocale } from "@/components/i18n/LocaleProvider";
+
+interface SectionForm {
+  key: string | null; // null = neue Essenszeit
+  label: string;
+  translations: Record<string, string>;
+  timeFrom: string;
+  timeTo: string;
+}
+
+const EMPTY_FORM: SectionForm = {
+  key: null,
+  label: "",
+  translations: {},
+  timeFrom: "",
+  timeTo: "",
+};
+
+function splitTimeRange(range: string): { from: string; to: string } {
+  const [from, to] = range.split("-").map((s) => s.trim());
+  return { from: from ?? "", to: to ?? "" };
+}
+
+export default function SectionManager() {
+  const dict = useDict();
+  const locale = useLocale();
+  const languages = useLanguages().filter((l) => l.code !== "de");
+  const [sections, setSections] = useState<Section[]>([]);
+  const [form, setForm] = useState<SectionForm | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [busy, setBusy] = useState(false);
+
+  const load = useCallback(async () => {
+    const res = await fetch("/api/sections");
+    if (!res.ok)
+      setError(formatMessage(dict.sectionManager.loadError, { message: String(res.status) }));
+    else setSections(await res.json());
+    setLoading(false);
+  }, [dict]);
+
+  useEffect(() => {
+    load();
+  }, [load]);
+
+  async function save(e: React.FormEvent) {
+    e.preventDefault();
+    if (!form) return;
+    setError(null);
+    const label = form.label.trim();
+    if (!label || !form.timeFrom || !form.timeTo) return;
+    const payload = {
+      label,
+      time_range: `${form.timeFrom} - ${form.timeTo}`,
+      translations: form.translations,
+    };
+
+    const res = form.key
+      ? await fetch(`/api/sections/${form.key}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+        })
+      : await fetch("/api/sections", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+        });
+    if (!res.ok) {
+      setError(formatMessage(dict.sectionManager.saveError, { message: String(res.status) }));
+      return;
+    }
+    setForm(null);
+    await load();
+  }
+
+  async function remove(section: Section) {
+    if (
+      !window.confirm(
+        formatMessage(dict.sectionManager.confirmDelete, { name: section.label })
+      )
+    )
+      return;
+    const res = await fetch(`/api/sections/${section.key}`, { method: "DELETE" });
+    if (!res.ok)
+      setError(formatMessage(dict.sectionManager.deleteError, { message: String(res.status) }));
+    await load();
+  }
+
+  async function move(section: Section, direction: -1 | 1) {
+    const idx = sections.findIndex((s) => s.key === section.key);
+    const neighbor = sections[idx + direction];
+    if (!neighbor) return;
+    setBusy(true);
+    setError(null);
+    const [r1, r2] = await Promise.all([
+      fetch(`/api/sections/${section.key}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ sort: neighbor.sort }),
+      }),
+      fetch(`/api/sections/${neighbor.key}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ sort: section.sort }),
+      }),
+    ]);
+    if (!r1.ok || !r2.ok)
+      setError(formatMessage(dict.sectionManager.saveError, { message: "move failed" }));
+    setBusy(false);
+    await load();
+  }
+
+  return (
+    <div className="max-w-3xl">
+      <div className="flex flex-wrap items-center gap-3 mb-4">
+        <h1 className="text-xl font-bold text-[var(--c-primary)] mr-auto">
+          {dict.sectionManager.title}
+        </h1>
+        <button
+          type="button"
+          className="btn btn-add"
+          onClick={() => setForm(EMPTY_FORM)}
+        >
+          {dict.sectionManager.newSection}
+        </button>
+      </div>
+
+      {error && (
+        <p className="mb-3 text-sm text-[var(--c-del)]" role="alert">
+          {error}
+        </p>
+      )}
+
+      {form && (
+        <form onSubmit={save} className="card mb-4 space-y-4">
+          <h2 className="font-semibold">
+            {form.key ? dict.sectionManager.editSection : dict.sectionManager.newSection}
+          </h2>
+          <div>
+            <label className="label" htmlFor="section-label">
+              {dict.sectionManager.nameLabel}
+            </label>
+            <input
+              id="section-label"
+              className="input"
+              value={form.label}
+              onChange={(e) => setForm({ ...form, label: e.target.value })}
+              required
+            />
+          </div>
+          {languages.length > 0 && (
+            <div className="grid gap-3 sm:grid-cols-2">
+              {languages.map((lang) => (
+                <div key={lang.code}>
+                  <label className="label" htmlFor={`section-label-${lang.code}`}>
+                    {lang.label}
+                  </label>
+                  <input
+                    id={`section-label-${lang.code}`}
+                    className="input"
+                    value={form.translations[lang.code] ?? ""}
+                    onChange={(e) =>
+                      setForm({
+                        ...form,
+                        translations: { ...form.translations, [lang.code]: e.target.value },
+                      })
+                    }
+                  />
+                </div>
+              ))}
+            </div>
+          )}
+          <div className="flex gap-3">
+            <div className="max-w-32">
+              <label className="label" htmlFor="section-time-from">
+                {dict.sectionManager.timeFrom}
+              </label>
+              <input
+                id="section-time-from"
+                type="time"
+                className="input"
+                value={form.timeFrom}
+                onChange={(e) => setForm({ ...form, timeFrom: e.target.value })}
+                required
+              />
+            </div>
+            <div className="max-w-32">
+              <label className="label" htmlFor="section-time-to">
+                {dict.sectionManager.timeTo}
+              </label>
+              <input
+                id="section-time-to"
+                type="time"
+                className="input"
+                value={form.timeTo}
+                onChange={(e) => setForm({ ...form, timeTo: e.target.value })}
+                required
+              />
+            </div>
+          </div>
+          <div className="flex gap-2">
+            <button type="submit" className="btn btn-add">
+              {dict.common.save}
+            </button>
+            <button
+              type="button"
+              className="btn btn-neutral"
+              onClick={() => setForm(null)}
+            >
+              {dict.common.cancel}
+            </button>
+          </div>
+        </form>
+      )}
+
+      {loading ? (
+        <p className="text-gray-500">{dict.common.loading}</p>
+      ) : (
+        <ul className="divide-y divide-gray-200 border border-gray-200 rounded-md bg-white">
+          {sections.map((section, idx) => (
+            <li key={section.key} className="flex flex-wrap items-center gap-3 px-4 py-2">
+              <div className="flex flex-col">
+                <button
+                  type="button"
+                  className="text-gray-400 hover:text-[var(--c-primary)] disabled:opacity-30"
+                  onClick={() => move(section, -1)}
+                  disabled={busy || idx === 0}
+                  aria-label={dict.sectionManager.moveUp}
+                  title={dict.sectionManager.moveUp}
+                >
+                  ▲
+                </button>
+                <button
+                  type="button"
+                  className="text-gray-400 hover:text-[var(--c-primary)] disabled:opacity-30"
+                  onClick={() => move(section, 1)}
+                  disabled={busy || idx === sections.length - 1}
+                  aria-label={dict.sectionManager.moveDown}
+                  title={dict.sectionManager.moveDown}
+                >
+                  ▼
+                </button>
+              </div>
+              <span className="mr-auto">
+                <span className="font-semibold">{localized(section, locale)}</span>{" "}
+                <span className="text-gray-500">– {section.time_range}</span>
+              </span>
+              <button
+                type="button"
+                className="btn btn-primary"
+                onClick={() => {
+                  const { from, to } = splitTimeRange(section.time_range);
+                  setForm({
+                    key: section.key,
+                    label: section.label,
+                    translations: { ...section.translations },
+                    timeFrom: from,
+                    timeTo: to,
+                  });
+                }}
+              >
+                {dict.common.edit}
+              </button>
+              <button
+                type="button"
+                className="btn btn-del"
+                onClick={() => remove(section)}
+              >
+                {dict.common.delete}
+              </button>
+            </li>
+          ))}
+          {sections.length === 0 && (
+            <li className="px-4 py-3 text-gray-500">{dict.sectionManager.empty}</li>
+          )}
+        </ul>
+      )}
+    </div>
+  );
+}
@@ -0,0 +1,127 @@
+"use client";
+
+import { useState } from "react";
+import Link from "next/link";
+import { formatMessage } from "@/lib/i18n/shared";
+import { useDict } from "@/components/i18n/LocaleProvider";
+import LanguageSwitcher from "@/components/i18n/LanguageSwitcher";
+
+export default function SuggestionForm() {
+  const dict = useDict();
+  const [name, setName] = useState("");
+  const [description, setDescription] = useState("");
+  // Honeypot: für echte Nutzer unsichtbares Feld. Füllt ein Bot es aus,
+  // tun wir so, als sei alles gut gegangen, ohne wirklich zu speichern.
+  const [website, setWebsite] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [success, setSuccess] = useState(false);
+  const [busy, setBusy] = useState(false);
+
+  async function submit(e: React.FormEvent) {
+    e.preventDefault();
+    setError(null);
+    const trimmedName = name.trim();
+    if (!trimmedName) {
+      setError(dict.suggestions.nameRequired);
+      return;
+    }
+    if (website.trim()) {
+      // Bot-Falle ausgelöst: keine echte Anfrage, aber Erfolg vortäuschen.
+      setSuccess(true);
+      return;
+    }
+    setBusy(true);
+
+    const res = await fetch("/api/dish-suggestions", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: trimmedName, description: description.trim() || null }),
+    });
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      setError(
+        data.error === "duplicate"
+          ? dict.suggestions.duplicate
+          : formatMessage(dict.suggestions.genericError, {
+              message: data.error ?? String(res.status),
+            })
+      );
+      setBusy(false);
+      return;
+    }
+    setSuccess(true);
+    setBusy(false);
+  }
+
+  return (
+    <div className="flex-1 flex items-center justify-center p-4">
+      <div className="card w-full max-w-md">
+        <div className="flex justify-between items-center mb-1">
+          <h1 className="text-xl font-bold text-[var(--c-primary)]">
+            {dict.suggestions.formTitle}
+          </h1>
+          <LanguageSwitcher variant="light" />
+        </div>
+        <p className="text-sm text-gray-600 mb-4">{dict.suggestions.formHint}</p>
+
+        {success ? (
+          <p className="text-sm text-green-700">{dict.suggestions.success}</p>
+        ) : (
+          <form onSubmit={submit} className="space-y-3">
+            <div>
+              <label className="label" htmlFor="suggestion-name">
+                {dict.suggestions.nameLabel}
+              </label>
+              <input
+                id="suggestion-name"
+                className="input"
+                value={name}
+                onChange={(e) => setName(e.target.value)}
+                required
+              />
+            </div>
+            <div>
+              <label className="label" htmlFor="suggestion-description">
+                {dict.suggestions.descriptionLabel}
+              </label>
+              <textarea
+                id="suggestion-description"
+                className="input"
+                rows={3}
+                value={description}
+                onChange={(e) => setDescription(e.target.value)}
+              />
+            </div>
+            {/* Honeypot – für Menschen unsichtbar, keine echten Nutzerdaten */}
+            <div className="absolute -left-[9999px]" aria-hidden="true">
+              <label htmlFor="website">Website</label>
+              <input
+                id="website"
+                name="website"
+                type="text"
+                tabIndex={-1}
+                autoComplete="off"
+                value={website}
+                onChange={(e) => setWebsite(e.target.value)}
+              />
+            </div>
+            {error && (
+              <p className="text-sm text-[var(--c-del)]" role="alert">
+                {error}
+              </p>
+            )}
+            <button type="submit" className="btn btn-primary w-full" disabled={busy}>
+              {busy ? dict.suggestions.submitting : dict.suggestions.submit}
+            </button>
+          </form>
+        )}
+
+        <p className="mt-4 text-center text-sm">
+          <Link href="/" className="text-gray-500 hover:text-[var(--c-primary)]">
+            {dict.suggestions.backToMenu}
+          </Link>
+        </p>
+      </div>
+    </div>
+  );
+}
@@ -0,0 +1,116 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import { formatMessage } from "@/lib/i18n/shared";
+import { useDict } from "@/components/i18n/LocaleProvider";
+import type { DishSuggestion } from "@/lib/types";
+
+export default function SuggestionReview() {
+  const dict = useDict();
+  const [items, setItems] = useState<DishSuggestion[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [info, setInfo] = useState<string | null>(null);
+  const [busyId, setBusyId] = useState<string | null>(null);
+
+  const load = useCallback(async () => {
+    const res = await fetch("/api/dish-suggestions");
+    if (!res.ok)
+      setError(formatMessage(dict.suggestions.loadError, { message: String(res.status) }));
+    else setItems(await res.json());
+    setLoading(false);
+  }, [dict]);
+
+  useEffect(() => {
+    load();
+  }, [load]);
+
+  async function accept(item: DishSuggestion) {
+    setBusyId(item.id);
+    setError(null);
+    setInfo(null);
+    const res = await fetch(`/api/dish-suggestions/${item.id}/accept`, { method: "POST" });
+    if (!res.ok) {
+      setError(formatMessage(dict.suggestions.actionError, { message: String(res.status) }));
+      setBusyId(null);
+      return;
+    }
+    setInfo(dict.suggestions.accepted);
+    setBusyId(null);
+    await load();
+  }
+
+  async function reject(item: DishSuggestion) {
+    if (!window.confirm(formatMessage(dict.suggestions.confirmReject, { name: item.name })))
+      return;
+    setBusyId(item.id);
+    setError(null);
+    setInfo(null);
+    const res = await fetch(`/api/dish-suggestions/${item.id}`, { method: "DELETE" });
+    if (!res.ok) {
+      setError(formatMessage(dict.suggestions.actionError, { message: String(res.status) }));
+    } else {
+      setInfo(dict.suggestions.rejected);
+    }
+    setBusyId(null);
+    await load();
+  }
+
+  return (
+    <div className="max-w-3xl">
+      <h1 className="text-xl font-bold text-[var(--c-primary)] mb-4">
+        {dict.suggestions.reviewTitle}
+      </h1>
+
+      {error && (
+        <p className="mb-3 text-sm text-[var(--c-del)]" role="alert">
+          {error}
+        </p>
+      )}
+      {info && <p className="mb-3 text-sm text-green-700">{info}</p>}
+
+      {loading ? (
+        <p className="text-gray-500">{dict.common.loading}</p>
+      ) : (
+        <ul className="divide-y divide-gray-200 border border-gray-200 rounded-md bg-white">
+          {items.map((item) => (
+            <li key={item.id} className="flex flex-wrap items-center gap-3 px-4 py-3">
+              <span className="mr-auto">
+                <span className="font-semibold">{item.name}</span>
+                {item.description && (
+                  <span className="block text-sm text-gray-600 mt-0.5">
+                    {item.description}
+                  </span>
+                )}
+                <span className="block text-xs text-gray-400 mt-0.5">
+                  {formatMessage(dict.suggestions.submittedOn, {
+                    date: new Date(item.created_at).toLocaleDateString(dict.dateLocale),
+                  })}
+                </span>
+              </span>
+              <button
+                type="button"
+                className="btn btn-add"
+                onClick={() => accept(item)}
+                disabled={busyId === item.id}
+              >
+                {dict.suggestions.accept}
+              </button>
+              <button
+                type="button"
+                className="btn btn-del"
+                onClick={() => reject(item)}
+                disabled={busyId === item.id}
+              >
+                {dict.suggestions.reject}
+              </button>
+            </li>
+          ))}
+          {items.length === 0 && (
+            <li className="px-4 py-3 text-gray-500">{dict.suggestions.reviewEmpty}</li>
+          )}
+        </ul>
+      )}
+    </div>
+  );
+}
@@ -1,8 +1,9 @@
 "use client";

-import { useCallback, useEffect, useMemo, useState } from "react";
-import { createClient } from "@/lib/supabase/client";
+import { useCallback, useEffect, useState } from "react";
+import { formatMessage } from "@/lib/i18n/shared";
 import type { Profile, Role } from "@/lib/types";
+import { useDict } from "@/components/i18n/LocaleProvider";

 interface UserForm {
  id: string | null; // null = neuer Benutzer
@@ -10,6 +11,7 @@ interface UserForm {
  full_name: string;
  role: Role;
  password: string; // bei Bearbeitung optional (leer = unverändert)
+  passwordRepeat: string;
 }

 const EMPTY_FORM: UserForm = {
@@ -18,31 +20,26 @@ const EMPTY_FORM: UserForm = {
  full_name: "",
  role: "staff",
  password: "",
+  passwordRepeat: "",
 };

-const ROLE_LABELS: Record<Role, string> = {
-  admin: "Administrator",
-  staff: "Kantinenmitarbeiter",
+export default function UserManager({ meId }: { meId: string }) {
+  const dict = useDict();
+  const roleLabels: Record<Role, string> = {
+    admin: dict.common.roleAdmin,
+    staff: dict.common.roleStaff,
  };
-
-export default function UserManager() {
-  const supabase = useMemo(() => createClient(), []);
  const [profiles, setProfiles] = useState<Profile[]>([]);
-  const [me, setMe] = useState<string | null>(null);
  const [form, setForm] = useState<UserForm | null>(null);
  const [error, setError] = useState<string | null>(null);
  const [busy, setBusy] = useState(false);

  const load = useCallback(async () => {
-    const [{ data: profileData, error: profileError }, { data: userData }] =
-      await Promise.all([
-        supabase.from("profiles").select("*").order("created_at"),
-        supabase.auth.getUser(),
-      ]);
-    if (profileError) setError(`Laden fehlgeschlagen: ${profileError.message}`);
-    else setProfiles(profileData as Profile[]);
-    setMe(userData.user?.id ?? null);
-  }, [supabase]);
+    const res = await fetch("/api/admin/users");
+    if (!res.ok)
+      setError(formatMessage(dict.userManager.loadError, { message: String(res.status) }));
+    else setProfiles(await res.json());
+  }, [dict]);

  useEffect(() => {
    load();
@@ -74,6 +71,10 @@ export default function UserManager() {
  async function save(e: React.FormEvent) {
    e.preventDefault();
    if (!form) return;
+    if (form.password && form.password !== form.passwordRepeat) {
+      setError(dict.userManager.passwordMismatch);
+      return;
+    }
    const ok = form.id
      ? await callApi("PATCH", {
          id: form.id,
@@ -96,7 +97,7 @@ export default function UserManager() {
  async function remove(profile: Profile) {
    if (
      !window.confirm(
-        `Benutzer „${profile.email}“ wirklich löschen? Der Zugang wird dauerhaft entfernt.`
+        formatMessage(dict.userManager.confirmDelete, { email: profile.email })
      )
    )
      return;
@@ -105,16 +106,16 @@ export default function UserManager() {

  return (
    <div className="max-w-3xl">
-      <div className="flex items-center gap-3 mb-4">
+      <div className="flex flex-wrap items-center gap-3 mb-4">
        <h1 className="text-xl font-bold text-[var(--c-primary)] mr-auto">
-          Benutzer
+          {dict.userManager.title}
        </h1>
        <button
          type="button"
          className="btn btn-add"
          onClick={() => setForm(EMPTY_FORM)}
        >
-          Neuer Benutzer
+          {dict.userManager.newUser}
        </button>
      </div>

@@ -127,12 +128,12 @@ export default function UserManager() {
      {form && (
        <form onSubmit={save} className="card mb-4 space-y-3">
          <h2 className="font-semibold">
-            {form.id ? "Benutzer bearbeiten" : "Neuer Benutzer"}
+            {form.id ? dict.userManager.editUser : dict.userManager.newUser}
          </h2>
          {!form.id && (
            <div>
              <label className="label" htmlFor="user-email">
-                E-Mail-Adresse
+                {dict.common.email}
              </label>
              <input
                id="user-email"
@@ -146,7 +147,7 @@ export default function UserManager() {
          )}
          <div>
            <label className="label" htmlFor="user-name">
-              Name
+              {dict.common.name}
            </label>
            <input
              id="user-name"
@@ -157,7 +158,7 @@ export default function UserManager() {
          </div>
          <div className="max-w-60">
            <label className="label" htmlFor="user-role">
-              Rolle
+              {dict.common.role}
            </label>
            <select
              id="user-role"
@@ -167,13 +168,13 @@ export default function UserManager() {
                setForm({ ...form, role: e.target.value as Role })
              }
            >
-              <option value="staff">Kantinenmitarbeiter</option>
-              <option value="admin">Administrator</option>
+              <option value="staff">{dict.common.roleStaff}</option>
+              <option value="admin">{dict.common.roleAdmin}</option>
            </select>
          </div>
          <div className="max-w-60">
            <label className="label" htmlFor="user-password">
-              {form.id ? "Neues Passwort (optional)" : "Passwort"}
+              {form.id ? dict.userManager.newPasswordLabel : dict.common.password}
            </label>
            <input
              id="user-password"
@@ -186,16 +187,33 @@ export default function UserManager() {
              autoComplete="new-password"
            />
          </div>
+          <div className="max-w-60">
+            <label className="label" htmlFor="user-password-repeat">
+              {dict.userManager.repeatPasswordLabel}
+            </label>
+            <input
+              id="user-password-repeat"
+              type="password"
+              className="input"
+              value={form.passwordRepeat}
+              onChange={(e) =>
+                setForm({ ...form, passwordRepeat: e.target.value })
+              }
+              minLength={8}
+              required={!form.id || !!form.password}
+              autoComplete="new-password"
+            />
+          </div>
          <div className="flex gap-2">
            <button type="submit" className="btn btn-add" disabled={busy}>
-              Speichern
+              {dict.common.save}
            </button>
            <button
              type="button"
              className="btn btn-neutral"
              onClick={() => setForm(null)}
            >
-              Abbrechen
+              {dict.common.cancel}
            </button>
          </div>
        </form>
@@ -203,13 +221,13 @@ export default function UserManager() {

      <ul className="divide-y divide-gray-200 border border-gray-200 rounded-md bg-white">
        {profiles.map((p) => (
-          <li key={p.id} className="flex items-center gap-3 px-4 py-2 text-sm">
+          <li key={p.id} className="flex flex-wrap items-center gap-3 px-4 py-2 text-sm">
            <span className="mr-auto">
              <span className="font-semibold">{p.full_name || p.email}</span>{" "}
              <span className="text-gray-500">
-                – {p.email} – {ROLE_LABELS[p.role]}
+                – {p.email} – {roleLabels[p.role]}
              </span>
-              {p.id === me && <span className="text-gray-400"> (du)</span>}
+              {p.id === meId && <span className="text-gray-400"> {dict.common.you}</span>}
            </span>
            <button
              type="button"
@@ -221,18 +239,19 @@ export default function UserManager() {
                  full_name: p.full_name,
                  role: p.role,
                  password: "",
+                  passwordRepeat: "",
                })
              }
            >
-              Bearbeiten
+              {dict.common.edit}
            </button>
-            {p.id !== me && (
+            {p.id !== meId && (
              <button
                type="button"
                className="btn btn-del"
                onClick={() => remove(p)}
              >
-                Löschen
+                {dict.common.delete}
              </button>
            )}
          </li>
@@ -1,22 +1,45 @@
 "use client";

-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useState } from "react";
 import Link from "next/link";
-import { createClient } from "@/lib/supabase/client";
-import { addDays, formatDateLong, formatPrice, WEEKDAYS } from "@/lib/menu";
-import type { Dish, MenuEntry, Section } from "@/lib/types";
+import {
+  addDays,
+  dishCodes,
+  entriesFor,
+  formatDateLong,
+  formatPrice,
+  mondayOf,
+  todayISO,
+  weekdayIndex,
+} from "@/lib/menu";
+import { formatMessage } from "@/lib/i18n/shared";
+import { localized } from "@/lib/types";
+import type { ClosedDay, Dish, MenuEntry, Section } from "@/lib/types";
+import { useDict, useLanguages, useLocale } from "@/components/i18n/LocaleProvider";

-export default function WeekEditor({ monday }: { monday: string }) {
-  const supabase = useMemo(() => createClient(), []);
+export default function WeekEditor({
+  monday,
+  translateEnabled,
+}: {
+  monday: string;
+  translateEnabled: boolean;
+}) {
+  const dict = useDict();
+  const locale = useLocale();
+  const languages = useLanguages().filter((l) => l.code !== "de");
  const friday = addDays(monday, 4);
-  const days = WEEKDAYS.map((weekday, i) => ({
+  const days = dict.weekdays.long.map((weekday, i) => ({
    weekday,
+    short: dict.weekdays.short[i],
    iso: addDays(monday, i),
  }));
+  const isCurrentWeek = monday === mondayOf(todayISO());
+  const todayIdx = isCurrentWeek ? weekdayIndex(todayISO()) : -1;

  const [sections, setSections] = useState<Section[]>([]);
  const [dishes, setDishes] = useState<Dish[]>([]);
  const [entries, setEntries] = useState<MenuEntry[]>([]);
+  const [closedDays, setClosedDays] = useState<ClosedDay[]>([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);
  // Zelle, in der gerade ein Gericht hinzugefügt wird
@@ -24,30 +47,53 @@ export default function WeekEditor({ monday }: { monday: string }) {
    null
  );
  const [selectedDish, setSelectedDish] = useState("");
+  const [dishSearch, setDishSearch] = useState("");
+  // Mobil: ein Tag auf einmal statt aller fünf gleichzeitig
+  const [selectedDayIdx, setSelectedDayIdx] = useState(todayIdx >= 0 ? todayIdx : 0);
+
+  // Tag, für den gerade das Schließen-Formular offen ist
+  const [closingIso, setClosingIso] = useState<string | null>(null);
+  const [closeReason, setCloseReason] = useState("");
+  const [closeTranslations, setCloseTranslations] = useState<Record<string, string>>({});
+  const [closeTranslateState, setCloseTranslateState] = useState<"idle" | "busy" | "done">(
+    "idle"
+  );
+  const [closeBusy, setCloseBusy] = useState(false);
+
+  function closedDayFor(iso: string): ClosedDay | undefined {
+    return closedDays.find((c) => c.closed_date === iso);
+  }
+
+  function startAdding(iso: string, section: string) {
+    setAdding({ iso, section });
+    setSelectedDish("");
+    setDishSearch("");
+  }
+
+  function cancelAdding() {
+    setAdding(null);
+    setSelectedDish("");
+    setDishSearch("");
+  }

  const load = useCallback(async () => {
    setError(null);
-    const [se, di, en] = await Promise.all([
-      supabase.from("sections").select("*").order("sort"),
-      supabase.from("dishes").select("*").order("name"),
-      supabase
-        .from("menu_entries")
-        .select("id, menu_date, section_key, position, dish:dishes(id, name, price)")
-        .gte("menu_date", monday)
-        .lte("menu_date", friday)
-        .order("position")
-        .order("created_at"),
+    const [se, di, en, cd] = await Promise.all([
+      fetch("/api/sections"),
+      fetch("/api/dishes"),
+      fetch(`/api/menu-entries?from=${monday}&to=${friday}`),
+      fetch(`/api/closed-days?from=${monday}&to=${friday}`),
    ]);
-    const problem = se.error ?? di.error ?? en.error;
-    if (problem) {
-      setError(`Laden fehlgeschlagen: ${problem.message}`);
+    if (!se.ok || !di.ok || !en.ok || !cd.ok) {
+      setError(formatMessage(dict.weekEditor.loadError, { message: "load failed" }));
    } else {
-      setSections(se.data as Section[]);
-      setDishes(di.data as Dish[]);
-      setEntries(en.data as unknown as MenuEntry[]);
+      setSections(await se.json());
+      setDishes(await di.json());
+      setEntries(await en.json());
+      setClosedDays(await cd.json());
    }
    setLoading(false);
-  }, [supabase, monday, friday]);
+  }, [monday, friday, dict]);

  useEffect(() => {
    setLoading(true);
@@ -56,82 +102,253 @@ export default function WeekEditor({ monday }: { monday: string }) {

  async function addEntry() {
    if (!adding || !selectedDish) return;
-    const { error } = await supabase.from("menu_entries").insert({
+    const res = await fetch("/api/menu-entries", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
        menu_date: adding.iso,
        section_key: adding.section,
        dish_id: selectedDish,
+      }),
    });
-    if (error) {
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
      setError(
-        /duplicate key/i.test(error.message)
-          ? "Dieses Gericht ist an diesem Tag bereits zugewiesen."
-          : `Speichern fehlgeschlagen: ${error.message}`
+        data.error === "duplicate_entry"
+          ? dict.weekEditor.duplicateEntry
+          : formatMessage(dict.weekEditor.saveError, { message: data.error ?? String(res.status) })
      );
    }
-    setAdding(null);
-    setSelectedDish("");
+    cancelAdding();
    await load();
  }

  async function removeEntry(id: string) {
-    const { error } = await supabase.from("menu_entries").delete().eq("id", id);
-    if (error) setError(`Löschen fehlgeschlagen: ${error.message}`);
+    const res = await fetch(`/api/menu-entries/${id}`, { method: "DELETE" });
+    if (!res.ok)
+      setError(formatMessage(dict.weekEditor.deleteError, { message: String(res.status) }));
    await load();
  }

-  const cell = (iso: string, sectionKey: string) =>
-    entries.filter((e) => e.menu_date === iso && e.section_key === sectionKey);
+  function startClosing(iso: string) {
+    const existing = closedDayFor(iso);
+    setClosingIso(iso);
+    setCloseReason(existing?.reason ?? "");
+    setCloseTranslations({ ...(existing?.translations ?? {}) });
+    setCloseTranslateState("idle");
+  }

+  function cancelClosing() {
+    setClosingIso(null);
+  }
+
+  async function saveClosing() {
+    if (!closingIso) return;
+    setCloseBusy(true);
+    setError(null);
+    const res = await fetch("/api/closed-days", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        closed_date: closingIso,
+        reason: closeReason.trim() || null,
+        translations: closeTranslations,
+      }),
+    });
+    setCloseBusy(false);
+    if (!res.ok) {
+      setError(formatMessage(dict.weekEditor.saveError, { message: String(res.status) }));
+      return;
+    }
+    setClosingIso(null);
+    await load();
+  }
+
+  async function reopenDay(iso: string) {
+    setCloseBusy(true);
+    setError(null);
+    const res = await fetch(`/api/closed-days/${iso}`, { method: "DELETE" });
+    setCloseBusy(false);
+    if (!res.ok) {
+      setError(formatMessage(dict.weekEditor.deleteError, { message: String(res.status) }));
+      return;
+    }
+    if (closingIso === iso) setClosingIso(null);
+    await load();
+  }
+
+  async function autoTranslateClosing() {
+    if (!closingIso || !closeReason.trim()) return;
+    setCloseTranslateState("busy");
+    setError(null);
+    try {
+      const res = await fetch("/api/translate", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          table: "closed_days",
+          id: closedDayFor(closingIso) ? closingIso : null,
+          text: closeReason.trim(),
+        }),
+      });
+      const data = await res.json();
+      if (!res.ok) throw new Error(data?.error ?? `Fehler (${res.status})`);
+      setCloseTranslations((prev) => ({ ...prev, ...(data.translations ?? {}) }));
+      setCloseTranslateState("done");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      setCloseTranslateState("idle");
+    }
+  }
+
+  const [hintBefore, hintAfter] = dict.weekEditor.newDishesHint.split("{link}");
+  const selectedDishObj = dishes.find((d) => d.id === selectedDish) ?? null;
+  const query = dishSearch.trim().toLowerCase();
+  const filteredDishes = query
+    ? dishes.filter((d) => localized(d, locale).toLowerCase().includes(query))
+    : dishes;
+
+  // Kleines Schloss-Symbol neben dem Tagesdatum: 🔓 zum Schließen
+  // anklicken, 🔒 zeigt einen geschlossenen Tag und öffnet ihn per Klick
+  // wieder – der Zustand des Symbols selbst ist die Beschriftung.
+  function renderClosureToggle(iso: string) {
+    const closed = Boolean(closedDayFor(iso));
    return (
-    <div>
-      <div className="flex flex-wrap items-center gap-3 mb-4">
-        <h1 className="text-xl font-bold text-[var(--c-primary)] mr-auto">
-          Wochenplan
-        </h1>
-        <Link href={`/intern?woche=${addDays(monday, -7)}`} className="btn btn-add">
-          ← Vorherige Woche
-        </Link>
-        <Link href={`/intern?woche=${addDays(monday, 7)}`} className="btn btn-add">
-          Nächste Woche →
-        </Link>
+      <button
+        type="button"
+        className="mt-0.5 text-base leading-none align-middle opacity-70 hover:opacity-100 disabled:opacity-40"
+        onClick={() => (closed ? reopenDay(iso) : startClosing(iso))}
+        disabled={closeBusy}
+        title={closed ? dict.weekEditor.reopenDay : dict.weekEditor.closeDay}
+        aria-label={closed ? dict.weekEditor.reopenDay : dict.weekEditor.closeDay}
+      >
+        {closed ? "🔒" : "🔓"}
+      </button>
+    );
+  }
+
+  // Banner, das bei einem geschlossenen Tag alle Essenszeiten-Zellen
+  // dieses Tages ersetzt (Desktop: eine über rowSpan verbundene Zelle,
+  // Mobil: anstelle der Essenszeiten-Karten) – "Bearbeiten" öffnet das
+  // Formular erneut, um nur den Grund anzupassen, ohne den Tag über das
+  // Symbol im Header erst wieder öffnen zu müssen.
+  function renderClosedBanner(iso: string, closed: ClosedDay) {
+    return (
+      <div className="flex flex-col items-center justify-center gap-1 py-4 text-red-700">
+        <span className="text-2xl" aria-hidden>
+          🔒
+        </span>
+        <span className="font-semibold">{dict.weekEditor.closedLabel}</span>
+        {closed.reason && <span className="text-sm px-2 text-center">{closed.reason}</span>}
+        <button
+          type="button"
+          className="mt-1 text-xs text-gray-500 hover:text-[var(--c-primary)] underline"
+          onClick={() => startClosing(iso)}
+        >
+          {dict.common.edit}
+        </button>
      </div>
+    );
+  }

-      {error && (
-        <p className="mb-3 text-sm text-[var(--c-del)]" role="alert">
-          {error}
-        </p>
+  // Formular zum Schließen/Bearbeiten eines Tages – ein gemeinsames
+  // Formular für Desktop-Tabelle und mobile Tagesansicht, da immer nur
+  // ein Tag gleichzeitig bearbeitet werden kann.
+  function renderClosingForm() {
+    if (!closingIso) return null;
+    const day = days.find((d) => d.iso === closingIso);
+    return (
+      <form
+        onSubmit={(e) => {
+          e.preventDefault();
+          saveClosing();
+        }}
+        className="card mb-4 space-y-3"
+      >
+        <h2 className="font-semibold">
+          {dict.weekEditor.closeDay}: {day?.weekday} ·{" "}
+          {formatDateLong(closingIso, dict.dateLocale)}
+        </h2>
+        <div>
+          <label className="label" htmlFor="closed-reason">
+            {dict.weekEditor.closedReasonLabel}
+          </label>
+          <input
+            id="closed-reason"
+            className="input"
+            placeholder={dict.weekEditor.closedReasonPlaceholder}
+            value={closeReason}
+            onChange={(e) => setCloseReason(e.target.value)}
+          />
+        </div>
+        {languages.length > 0 && (
+          <div className="grid gap-3 sm:grid-cols-2">
+            {languages.map((lang) => (
+              <div key={lang.code}>
+                <label className="label" htmlFor={`closed-reason-${lang.code}`}>
+                  {lang.label}
+                </label>
+                <input
+                  id={`closed-reason-${lang.code}`}
+                  className="input"
+                  value={closeTranslations[lang.code] ?? ""}
+                  onChange={(e) =>
+                    setCloseTranslations({
+                      ...closeTranslations,
+                      [lang.code]: e.target.value,
+                    })
+                  }
+                />
+              </div>
+            ))}
+          </div>
+        )}
+        {translateEnabled && languages.length > 0 && (
+          <div>
+            <button
+              type="button"
+              className="btn btn-neutral"
+              onClick={autoTranslateClosing}
+              disabled={closeTranslateState === "busy" || !closeReason.trim()}
+            >
+              {closeTranslateState === "busy"
+                ? dict.dishManager.translating
+                : dict.dishManager.autoTranslate}
+            </button>
+            {closeTranslateState === "done" && (
+              <span className="ml-2 text-sm text-green-700">
+                {dict.dishManager.translated}
+              </span>
            )}
-      {loading ? (
-        <p className="text-gray-500">Lade Wochenplan…</p>
-      ) : (
-        <table className="menu-table">
-          <thead>
-            <tr>
-              <th className="section-head w-52" aria-hidden />
-              {days.map((d) => (
-                <th key={d.iso} className="day-head">
-                  <span className="font-bold">{d.weekday}</span>
-                  <br />
-                  {formatDateLong(d.iso)}
-                </th>
-              ))}
-            </tr>
-          </thead>
-          <tbody>
-            {sections.map((s) => (
-              <tr key={s.key}>
-                <th className="section-head">
-                  <div>{s.label}</div>
-                  <div className="time">{s.time_range}</div>
-                </th>
-                {days.map((d) => {
-                  const isAdding =
-                    adding?.iso === d.iso && adding?.section === s.key;
+          </div>
+        )}
+        <div className="flex gap-2">
+          <button type="submit" className="btn btn-add" disabled={closeBusy}>
+            {dict.common.save}
+          </button>
+          <button type="button" className="btn btn-neutral" onClick={cancelClosing}>
+            {dict.common.cancel}
+          </button>
+        </div>
+      </form>
+    );
+  }
+
+  // Inhalt einer Tag/Essenszeit-Zelle: Eintragsliste + "hinzufügen"-Flow.
+  // Identisches Fragment für Desktop-Tabelle und Mobile-Karten, damit der
+  // Bearbeitungs-Zustand (adding/selectedDish/dishSearch) nicht dupliziert
+  // werden muss – nur eine Zelle kann gleichzeitig bearbeitet werden,
+  // unabhängig davon, welche Ansicht gerade rendert.
+  function renderCell(iso: string, sectionKey: string) {
+    const isAdding = adding?.iso === iso && adding?.section === sectionKey;
+    return (
+      <>
+        {entriesFor(entries, iso, sectionKey).map((e) => {
+          const codes = dishCodes(e.dish);
          return (
-                    <td key={d.iso} className="cell">
-                      {cell(d.iso, s.key).map((e) => (
            <div key={e.id} className="dish">
-                          <span className="font-bold">{e.dish.name}</span>
+              <span className="font-bold">{localized(e.dish, locale)}</span>
+              {codes && <sup className="dish-codes">{codes}</sup>}
              {" – "}
              {formatPrice(e.dish.price)}
              <div className="mt-1">
@@ -140,25 +357,65 @@ export default function WeekEditor({ monday }: { monday: string }) {
                  className="btn btn-del"
                  onClick={() => removeEntry(e.id)}
                >
-                              Löschen
+                  {dict.common.delete}
                </button>
              </div>
            </div>
-                      ))}
+          );
+        })}
        {isAdding ? (
          <div className="mt-2 space-y-1 text-left">
-                          <select
-                            className="input"
-                            value={selectedDish}
-                            onChange={(e) => setSelectedDish(e.target.value)}
+            {selectedDishObj ? (
+              <div className="flex items-center gap-1 text-sm">
+                <span className="mr-auto">
+                  {localized(selectedDishObj, locale)} (
+                  {formatPrice(selectedDishObj.price)})
+                </span>
+                <button
+                  type="button"
+                  className="text-gray-400 hover:text-[var(--c-primary)]"
+                  onClick={() => {
+                    setSelectedDish("");
+                    setDishSearch("");
+                  }}
+                  aria-label={dict.weekEditor.changeDish}
+                  title={dict.weekEditor.changeDish}
                >
-                            <option value="">– Gericht wählen –</option>
-                            {dishes.map((dish) => (
-                              <option key={dish.id} value={dish.id}>
-                                {dish.name} ({formatPrice(dish.price)})
-                              </option>
+                  ×
+                </button>
+              </div>
+            ) : (
+              <>
+                <input
+                  type="search"
+                  className="input"
+                  autoFocus
+                  placeholder={dict.dishManager.searchPlaceholder}
+                  value={dishSearch}
+                  onChange={(e) => setDishSearch(e.target.value)}
+                />
+                <ul className="max-h-32 overflow-y-auto border border-gray-200 rounded-md bg-white divide-y divide-gray-100">
+                  {filteredDishes.map((dish) => (
+                    <li key={dish.id}>
+                      <button
+                        type="button"
+                        className="w-full text-left px-2 py-1 text-sm hover:bg-[var(--c-row-bg-alt)]"
+                        onClick={() => setSelectedDish(dish.id)}
+                      >
+                        {localized(dish, locale)} ({formatPrice(dish.price)})
+                      </button>
+                    </li>
                  ))}
-                          </select>
+                  {filteredDishes.length === 0 && (
+                    <li className="px-2 py-1 text-sm text-gray-500">
+                      {formatMessage(dict.dishManager.noResults, {
+                        query: dishSearch,
+                      })}
+                    </li>
+                  )}
+                </ul>
+              </>
+            )}
            <div className="flex gap-1 justify-center">
              <button
                type="button"
@@ -166,17 +423,10 @@ export default function WeekEditor({ monday }: { monday: string }) {
                onClick={addEntry}
                disabled={!selectedDish}
              >
-                              Hinzufügen
+                {dict.common.add}
              </button>
-                            <button
-                              type="button"
-                              className="btn btn-neutral"
-                              onClick={() => {
-                                setAdding(null);
-                                setSelectedDish("");
-                              }}
-                            >
-                              Abbrechen
+              <button type="button" className="btn btn-neutral" onClick={cancelAdding}>
+                {dict.common.cancel}
              </button>
            </div>
          </div>
@@ -184,14 +434,135 @@ export default function WeekEditor({ monday }: { monday: string }) {
          <button
            type="button"
            className="btn btn-add mt-1"
-                          onClick={() => {
-                            setAdding({ iso: d.iso, section: s.key });
-                            setSelectedDish("");
-                          }}
+            onClick={() => startAdding(iso, sectionKey)}
          >
-                          Mahlzeit hinzufügen
+            {dict.weekEditor.addMeal}
          </button>
        )}
+      </>
+    );
+  }
+
+  const selectedDay = days[selectedDayIdx];
+
+  return (
+    <div>
+      <div className="flex flex-wrap items-center gap-3 mb-4">
+        <h1 className="text-xl font-bold text-[var(--c-primary)] mr-auto">
+          {dict.weekEditor.title}
+        </h1>
+        <Link href={`/intern?woche=${addDays(monday, -7)}`} className="btn btn-add">
+          {dict.publicMenu.prevWeek}
+        </Link>
+        <Link
+          href={`/intern?woche=${mondayOf(todayISO())}`}
+          className="btn btn-primary"
+        >
+          {dict.publicMenu.today}
+        </Link>
+        <Link href={`/intern?woche=${addDays(monday, 7)}`} className="btn btn-add">
+          {dict.publicMenu.nextWeek}
+        </Link>
+      </div>
+
+      {error && (
+        <p className="mb-3 text-sm text-[var(--c-del)]" role="alert">
+          {error}
+        </p>
+      )}
+      {renderClosingForm()}
+      {loading ? (
+        <p className="text-gray-500">{dict.weekEditor.loading}</p>
+      ) : (
+        <>
+          {/* Mobil (< "sm"): ein Tag auf einmal, per Tabs gewählt */}
+          <div className="sm:hidden">
+            <div className="flex gap-1 mb-3">
+              {days.map((d, i) => (
+                <button
+                  key={d.iso}
+                  type="button"
+                  onClick={() => setSelectedDayIdx(i)}
+                  className={`flex-1 rounded-md py-1.5 text-sm font-semibold border transition-colors ${
+                    i === selectedDayIdx
+                      ? "bg-[var(--c-primary)] text-white border-[var(--c-primary)]"
+                      : "bg-white text-gray-600 border-gray-200"
+                  } ${i === todayIdx ? "ring-2 ring-[var(--c-accent)] ring-offset-1" : ""}`}
+                >
+                  {d.short}
+                </button>
+              ))}
+            </div>
+            <h2 className="font-bold text-[var(--c-primary)] mb-1">
+              {selectedDay.weekday} · {formatDateLong(selectedDay.iso, dict.dateLocale)}{" "}
+              {renderClosureToggle(selectedDay.iso)}
+            </h2>
+            {(() => {
+              const closed = closedDayFor(selectedDay.iso);
+              if (closed) {
+                return (
+                  <div className="rounded-md border border-red-200 bg-red-50">
+                    {renderClosedBanner(selectedDay.iso, closed)}
+                  </div>
+                );
+              }
+              return (
+                <div className="space-y-3">
+                  {sections.map((s) => (
+                    <div key={s.key} className="rounded-md border border-gray-200 overflow-hidden">
+                      <div className="bg-[var(--c-primary)] text-[var(--c-header-text)] px-3 py-1.5 text-sm">
+                        <span className="font-semibold">{localized(s, locale)}</span>{" "}
+                        <span className="opacity-80">· {s.time_range}</span>
+                      </div>
+                      <div className="bg-[var(--c-row-bg)] px-3 py-2 text-sm text-center">
+                        {renderCell(selectedDay.iso, s.key)}
+                      </div>
+                    </div>
+                  ))}
+                </div>
+              );
+            })()}
+          </div>
+
+          {/* Ab "sm": klassische Wochentabelle */}
+          <div className="hidden sm:block">
+            <table className="menu-table">
+              <thead>
+                <tr>
+                  <th className="section-head w-52" aria-hidden />
+                  {days.map((d) => (
+                    <th key={d.iso} className="day-head">
+                      <span className="font-bold">{d.weekday}</span>
+                      <br />
+                      {formatDateLong(d.iso, dict.dateLocale)} {renderClosureToggle(d.iso)}
+                    </th>
+                  ))}
+                </tr>
+              </thead>
+              <tbody>
+                {sections.map((s, sIdx) => (
+                  <tr key={s.key}>
+                    <th className="section-head">
+                      <div>{localized(s, locale)}</div>
+                      <div className="time">{s.time_range}</div>
+                    </th>
+                    {days.map((d) => {
+                      const closed = closedDayFor(d.iso);
+                      if (closed) {
+                        if (sIdx > 0) return null;
+                        return (
+                          <td
+                            key={d.iso}
+                            className="cell closed-cell"
+                            rowSpan={sections.length}
+                          >
+                            {renderClosedBanner(d.iso, closed)}
+                          </td>
+                        );
+                      }
+                      return (
+                        <td key={d.iso} className="cell">
+                          {renderCell(d.iso, s.key)}
                        </td>
                      );
                    })}
@@ -199,13 +570,15 @@ export default function WeekEditor({ monday }: { monday: string }) {
                ))}
              </tbody>
            </table>
+          </div>
+        </>
      )}
      <p className="mt-4 text-sm text-gray-500">
-        Neue Gerichte legst du unter{" "}
+        {hintBefore}
        <Link href="/intern/gerichte" className="underline">
-          Gerichte
-        </Link>{" "}
-        an.
+          {dict.weekEditor.newDishesLinkLabel}
+        </Link>
+        {hintAfter}
      </p>
    </div>
  );
@@ -0,0 +1,60 @@
+"use client";
+
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+import { useLanguages, useLocale } from "@/components/i18n/LocaleProvider";
+
+export default function LanguageSwitcher({
+  className = "",
+  variant = "dark",
+}: {
+  className?: string;
+  variant?: "dark" | "light";
+}) {
+  const locale = useLocale();
+  const languages = useLanguages();
+  const router = useRouter();
+  const [busy, setBusy] = useState(false);
+
+  async function change(next: string) {
+    if (next === locale || busy) return;
+    setBusy(true);
+    await fetch("/api/locale", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ locale: next }),
+    });
+    router.refresh();
+    setBusy(false);
+  }
+
+  // Bei nur einer aktiven Sprache gibt es nichts umzuschalten.
+  if (languages.length <= 1) return null;
+
+  const activeCls =
+    variant === "dark" ? "bg-white/25 text-white" : "bg-gray-200 text-gray-900";
+  const inactiveCls =
+    variant === "dark"
+      ? "text-white/60 hover:text-white hover:bg-white/10"
+      : "text-gray-400 hover:text-gray-700 hover:bg-gray-100";
+
+  return (
+    <div className={`flex gap-1 text-xs ${className}`} aria-label="Sprache">
+      {languages.map((l) => (
+        <button
+          key={l.code}
+          type="button"
+          onClick={() => change(l.code)}
+          disabled={busy}
+          aria-current={l.code === locale}
+          title={l.label}
+          className={`rounded px-1.5 py-0.5 uppercase font-semibold transition-colors ${
+            l.code === locale ? activeCls : inactiveCls
+          }`}
+        >
+          {l.code}
+        </button>
+      ))}
+    </div>
+  );
+}
@@ -0,0 +1,62 @@
+"use client";
+
+// Stellt Sprache + Wörterbuch + Liste der aktiven Sprachen für Client-
+// Komponenten bereit. Wird einmal im Root-Layout mit den serverseitig
+// ermittelten Werten instanziiert; Client-Komponenten lesen darüber
+// via useDict()/useLocale()/useLanguages().
+
+import { createContext, useContext, useMemo } from "react";
+import { formatMessage } from "@/lib/i18n/shared";
+import type { Dict, Locale } from "@/lib/i18n/shared";
+
+export interface LanguageInfo {
+  code: string;
+  label: string;
+}
+
+interface LocaleContextValue {
+  locale: Locale;
+  dict: Dict;
+  languages: LanguageInfo[];
+}
+
+const LocaleContext = createContext<LocaleContextValue | null>(null);
+
+export function LocaleProvider({
+  locale,
+  dict,
+  languages,
+  children,
+}: LocaleContextValue & { children: React.ReactNode }) {
+  const value = useMemo(
+    () => ({ locale, dict, languages }),
+    [locale, dict, languages]
+  );
+  return (
+    <LocaleContext.Provider value={value}>{children}</LocaleContext.Provider>
+  );
+}
+
+function useLocaleContext(): LocaleContextValue {
+  const ctx = useContext(LocaleContext);
+  if (!ctx) throw new Error("useDict/useLocale muss innerhalb von LocaleProvider verwendet werden.");
+  return ctx;
+}
+
+export function useDict(): Dict {
+  return useLocaleContext().dict;
+}
+
+export function useLocale(): Locale {
+  return useLocaleContext().locale;
+}
+
+/** Alle aktiven Sprachen (Code + Anzeigename), z. B. für den Sprachumschalter. */
+export function useLanguages(): LanguageInfo[] {
+  return useLocaleContext().languages;
+}
+
+/** t("Text mit {var}", { var: "Wert" }) für Platzhalter in Übersetzungen. */
+export function useFormatMessage() {
+  return formatMessage;
+}
@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+// Wendet alle noch nicht angewendeten Dateien aus db/migrations/*.sql auf
+// die per DATABASE_URL erreichbare Postgres-Datenbank an. Idempotent –
+// kann bei jedem App-Start gefahrlos erneut laufen (Docker-Entrypoint,
+// npm predev/prestart).
+
+import { readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import pg from "pg";
+
+const migrationsDir = join(dirname(fileURLToPath(import.meta.url)), "migrations");
+
+async function main() {
+  const client = new pg.Client({ connectionString: process.env.DATABASE_URL });
+  await client.connect();
+
+  try {
+    await client.query(`
+      create table if not exists schema_migrations (
+        filename   text primary key,
+        applied_at timestamptz not null default now()
+      )
+    `);
+
+    const { rows } = await client.query("select filename from schema_migrations");
+    const applied = new Set(rows.map((r) => r.filename));
+
+    const files = readdirSync(migrationsDir)
+      .filter((f) => f.endsWith(".sql"))
+      .sort();
+
+    for (const file of files) {
+      if (applied.has(file)) continue;
+      const sql = readFileSync(join(migrationsDir, file), "utf8");
+      console.log(`db:migrate – wende ${file} an…`);
+      await client.query("begin");
+      try {
+        await client.query(sql);
+        await client.query("insert into schema_migrations (filename) values ($1)", [file]);
+        await client.query("commit");
+      } catch (err) {
+        await client.query("rollback");
+        throw new Error(`Migration ${file} fehlgeschlagen: ${err.message}`, { cause: err });
+      }
+    }
+
+    console.log("db:migrate – Datenbank ist aktuell.");
+  } finally {
+    await client.end();
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
@@ -0,0 +1,156 @@
+-- =============================================================
+-- Canteen Menu – Initiales Schema (vollständig selbst gehostet)
+-- Rollen: admin (Benutzerverwaltung, Branding) / staff (Kantine)
+-- Öffentliche Speisekarte: lesbar ohne Login
+-- =============================================================
+
+-- ---------- Benutzer & Authentifizierung ----------
+create table users (
+  id                     uuid primary key default gen_random_uuid(),
+  email                  text not null unique,
+  password_hash          text not null,
+  full_name              text not null default '',
+  role                   text not null default 'staff' check (role in ('admin', 'staff')),
+  password_auth_enabled  boolean not null default true,
+  created_at             timestamptz not null default now()
+);
+
+-- Angemeldete Sitzungen. Es wird nur der Hash des Tokens gespeichert –
+-- der Rohwert im Cookie ist damit auch bei einem DB-Zugriff allein nicht
+-- verwendbar.
+create table sessions (
+  token_hash    text primary key,
+  user_id       uuid not null references users (id) on delete cascade,
+  created_at    timestamptz not null default now(),
+  expires_at    timestamptz not null,
+  last_seen_at  timestamptz not null default now()
+);
+create index sessions_user_id_idx on sessions (user_id);
+
+-- WebAuthn-Credentials (Passkeys) – eigenes Schema, wird von
+-- @simplewebauthn/server geprüft (lib/auth/).
+create table passkey_credentials (
+  id             uuid primary key default gen_random_uuid(),
+  user_id        uuid not null references users (id) on delete cascade,
+  credential_id  text not null unique,
+  public_key     bytea not null,
+  counter        bigint not null default 0,
+  transports     text[] not null default '{}',
+  name           text,
+  created_at     timestamptz not null default now(),
+  last_used_at   timestamptz
+);
+create index passkey_credentials_user_id_idx on passkey_credentials (user_id);
+
+-- Kurzlebige Challenges für laufende WebAuthn-Zeremonien (Registrierung
+-- oder Login). user_id ist beim Login-Flow anfangs null (Discoverable-
+-- Credential-Ansatz: die Identität steht erst nach der Antwort fest).
+create table webauthn_challenges (
+  id          uuid primary key default gen_random_uuid(),
+  user_id     uuid references users (id) on delete cascade,
+  challenge   text not null,
+  type        text not null check (type in ('registration', 'authentication')),
+  expires_at  timestamptz not null,
+  created_at  timestamptz not null default now()
+);
+
+-- ---------- Essenszeiten der Speisekarte ----------
+create table sections (
+  key        text primary key default (gen_random_uuid())::text,
+  label      text not null,
+  label_en   text,
+  label_pl   text,
+  time_range text not null,
+  sort       int  not null
+);
+
+-- ---------- Allergene & Zusatzstoffe ----------
+create table allergens (
+  code    text primary key,
+  name    text not null,
+  name_en text,
+  name_pl text,
+  sort    int  not null default 0
+);
+
+create table additives (
+  code    text primary key,
+  name    text not null,
+  name_en text,
+  name_pl text,
+  sort    int  not null default 0
+);
+
+-- ---------- Gerichte ----------
+create table dishes (
+  id         uuid primary key default gen_random_uuid(),
+  name       text not null,
+  name_en    text,
+  name_pl    text,
+  price      numeric(6, 2) not null default 0,
+  allergens  text[] not null default '{}',
+  additives  text[] not null default '{}',
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now()
+);
+
+create or replace function touch_updated_at()
+returns trigger
+language plpgsql
+as $$
+begin
+  new.updated_at := now();
+  return new;
+end;
+$$;
+
+create trigger dishes_touch_updated_at
+  before update on dishes
+  for each row execute function touch_updated_at();
+
+-- ---------- Zuweisung Gericht -> Tag/Essenszeit ----------
+create table menu_entries (
+  id          uuid primary key default gen_random_uuid(),
+  menu_date   date not null,
+  section_key text not null references sections (key) on delete cascade,
+  dish_id     uuid not null references dishes (id) on delete cascade,
+  position    int  not null default 0,
+  created_at  timestamptz not null default now(),
+  unique (menu_date, section_key, dish_id)
+);
+create index menu_entries_date_idx on menu_entries (menu_date);
+
+-- ---------- Einstellungen (Farben, Logo, Favicon) – genau eine Zeile ----------
+create table settings (
+  id           int primary key check (id = 1),
+  colors       jsonb not null default '{}'::jsonb,
+  logo_path    text,
+  favicon_path text,
+  updated_at   timestamptz not null default now()
+);
+
+insert into settings (id, colors) values (
+  1,
+  '{
+    "primary":    "#003388",
+    "primaryDark": "#0d315c",
+    "accent":     "#ff6900",
+    "headerText": "#ffffff",
+    "rowBg":      "#e3e4f1",
+    "rowBgAlt":   "#f4f4fa",
+    "addBtn":     "#6da54c",
+    "deleteBtn":  "#e2371d"
+  }'::jsonb
+);
+
+create trigger settings_touch_updated_at
+  before update on settings
+  for each row execute function touch_updated_at();
+
+-- ---------- Rezeptvorschläge ----------
+create table dish_suggestions (
+  id          uuid primary key default gen_random_uuid(),
+  name        text not null,
+  description text,
+  created_at  timestamptz not null default now()
+);
@@ -0,0 +1,11 @@
+-- Umschaltbare Anzeige der Allergene/Zusatzstoffe: entweder die
+-- detaillierte Auswahl je Gericht (bisheriges Verhalten) oder
+-- stattdessen nur ein von Personal/Admin editierbarer Hinweistext
+-- (z. B. "Bei Fragen bitte das Kantinen-Team fragen").
+alter table settings
+  add column labeling_mode text not null default 'detailed'
+    check (labeling_mode in ('detailed', 'notice')),
+  add column labeling_notice text not null default
+    'Bei Fragen zu Allergenen und Zusatzstoffen wenden Sie sich bitte an das Kantinen-Team.',
+  add column labeling_notice_en text,
+  add column labeling_notice_pl text;
@@ -0,0 +1,12 @@
+-- Kurzlebiger, einmalig verwendbarer State-Store für den OpenID-Connect-
+-- Login (SSO, z. B. gegen Authentik). Analog zu webauthn_challenges:
+-- der "state"-Wert selbst ist die CSRF-Absicherung für den Callback
+-- (der Callback ist ein Cross-Origin-GET vom Identity Provider, der
+-- normale isSameOrigin()-Check greift dort nicht).
+create table oidc_states (
+  state         text primary key,
+  nonce         text not null,
+  code_verifier text not null,
+  expires_at    timestamptz not null,
+  created_at    timestamptz not null default now()
+);
@@ -0,0 +1,34 @@
+-- Dynamisches Sprachpaket-System für die Bedienoberfläche: Sprachen
+-- sind ab jetzt zur Laufzeit im Admin-Bereich verwaltbar (aktivieren/
+-- deaktivieren, neue Sprache per Datei-Import hinzufügen) statt fest
+-- im Code zu stehen. Deutsch bleibt als "de"-Objekt in
+-- lib/i18n/dictionaries.ts die immer vollständige Basis-Sprache – sie
+-- braucht keine Zeilen in ui_translations, nur einen Eintrag in
+-- languages als Referenz für den Sprachumschalter.
+create table languages (
+  code             text primary key,
+  label            text not null,
+  is_base          boolean not null default false,
+  active           boolean not null default true,
+  -- Hash der DE-Vorlage (siehe lib/i18n/flatten.ts + lib/db/languages.ts)
+  -- zum Zeitpunkt des letzten Imports – weicht der aktuelle Hash davon
+  -- ab, sind seit dem Import neue Begriffe hinzugekommen ("veraltet").
+  -- Bei der Basis-Sprache immer null (nie veraltet, da Code = Vorlage).
+  template_version text,
+  updated_at       timestamptz not null default now()
+);
+
+-- Eine Zeile je Sprache + Übersetzungsschlüssel (z. B.
+-- "login.errorGeneric"), fehlende Schlüssel fallen zur Laufzeit
+-- automatisch auf die deutsche Vorlage zurück statt leer zu bleiben.
+create table ui_translations (
+  language_code text not null references languages(code) on delete cascade,
+  key           text not null,
+  value         text not null,
+  primary key (language_code, key)
+);
+
+insert into languages (code, label, is_base, active, template_version) values
+  ('de', 'Deutsch', true, true, null),
+  ('en', 'English', false, true, '2da2662b794f019f6f7dba99ef93e2035eb38d1a78bd73bdccbb6b3cab447d5d'),
+  ('pl', 'Polski', false, true, '2da2662b794f019f6f7dba99ef93e2035eb38d1a78bd73bdccbb6b3cab447d5d');
@@ -0,0 +1,574 @@
+-- Einmaliger Seed: bisherige fest im Code hinterlegte Englisch-/Polnisch-
+-- Übersetzungen (lib/i18n/dictionaries.ts) als Sprachpakete in
+-- ui_translations überführen, damit nach dem Umbau auf das dynamische
+-- Sprachpaket-System (siehe 0004_languages.sql) nichts verloren geht.
+
+insert into ui_translations (language_code, key, value) values
+  ('en', 'common.save', 'Save'),
+  ('en', 'common.cancel', 'Cancel'),
+  ('en', 'common.delete', 'Delete'),
+  ('en', 'common.edit', 'Edit'),
+  ('en', 'common.add', 'Add'),
+  ('en', 'common.back', 'Back'),
+  ('en', 'common.login', 'Log in'),
+  ('en', 'common.logout', 'Log out'),
+  ('en', 'common.loading', 'Loading…'),
+  ('en', 'common.you', '(you)'),
+  ('en', 'common.name', 'Name'),
+  ('en', 'common.email', 'Email address'),
+  ('en', 'common.password', 'Password'),
+  ('en', 'common.role', 'Role'),
+  ('en', 'common.roleAdmin', 'Administrator'),
+  ('en', 'common.roleStaff', 'Canteen staff'),
+  ('en', 'weekdays.long.0', 'Monday'),
+  ('en', 'weekdays.long.1', 'Tuesday'),
+  ('en', 'weekdays.long.2', 'Wednesday'),
+  ('en', 'weekdays.long.3', 'Thursday'),
+  ('en', 'weekdays.long.4', 'Friday'),
+  ('en', 'weekdays.short.0', 'Mon'),
+  ('en', 'weekdays.short.1', 'Tue'),
+  ('en', 'weekdays.short.2', 'Wed'),
+  ('en', 'weekdays.short.3', 'Thu'),
+  ('en', 'weekdays.short.4', 'Fri'),
+  ('en', 'dateLocale', 'en-GB'),
+  ('en', 'header.canteen', 'Canteen'),
+  ('en', 'header.menuGroup', 'Menu'),
+  ('en', 'header.weekPlan', 'Weekly plan'),
+  ('en', 'header.sections', 'Meal times'),
+  ('en', 'header.dishes', 'Dishes'),
+  ('en', 'header.labels', 'Allergens & Additives'),
+  ('en', 'header.adminGroup', 'Administration'),
+  ('en', 'header.users', 'Users'),
+  ('en', 'header.design', 'Design'),
+  ('en', 'header.languages', 'Languages'),
+  ('en', 'header.suggestions', 'Suggestions'),
+  ('en', 'header.openSuggestions', '{count} open dish suggestions'),
+  ('en', 'header.viewMenu', 'View menu'),
+  ('en', 'header.myAccount', 'My account'),
+  ('en', 'header.menuToggle', 'Open/close menu'),
+  ('en', 'login.title', 'Sign in'),
+  ('en', 'login.submit', 'Log in'),
+  ('en', 'login.or', 'or'),
+  ('en', 'login.passkeyButton', 'Sign in with passkey'),
+  ('en', 'login.ssoButton', 'Sign in with Single Sign-On'),
+  ('en', 'login.backToMenu', '← Back to menu'),
+  ('en', 'login.errorInvalidCredentials', 'Email address or password is incorrect.'),
+  ('en', 'login.errorPasskeyCancelled', 'Passkey sign-in was cancelled.'),
+  ('en', 'login.errorGeneric', 'Sign-in failed: {message}'),
+  ('en', 'login.errorPasswordDisabled', 'Password sign-in is disabled for this account. Please sign in with a passkey.'),
+  ('en', 'login.errorOidcInvalidState', 'The SSO sign-in expired or was invalid. Please try again.'),
+  ('en', 'login.errorOidcUnknownUser', 'No account exists for this email address. Please contact your administrator.'),
+  ('en', 'login.errorOidcFailed', 'SSO sign-in failed. Please try again.'),
+  ('en', 'publicMenu.prevWeek', '← Previous week'),
+  ('en', 'publicMenu.nextWeek', 'Next week →'),
+  ('en', 'publicMenu.prevWeekShort', '← Week'),
+  ('en', 'publicMenu.nextWeekShort', 'Week →'),
+  ('en', 'publicMenu.today', 'Today'),
+  ('en', 'publicMenu.dayTab', 'Day'),
+  ('en', 'publicMenu.weekTab', 'Week'),
+  ('en', 'publicMenu.allergens', 'Allergens'),
+  ('en', 'publicMenu.additives', 'Additives'),
+  ('en', 'publicMenu.labelingNoticeTitle', 'Allergens & additives'),
+  ('en', 'publicMenu.suggestDish', 'Suggest a dish'),
+  ('en', 'publicMenu.noEntry', '–'),
+  ('en', 'publicMenu.rssFeed', 'Subscribe to RSS feed'),
+  ('en', 'weekEditor.title', 'Weekly plan'),
+  ('en', 'weekEditor.loading', 'Loading weekly plan…'),
+  ('en', 'weekEditor.changeDish', 'Choose a different dish'),
+  ('en', 'weekEditor.addMeal', 'Add meal'),
+  ('en', 'weekEditor.newDishesHint', 'Add new dishes under {link}.'),
+  ('en', 'weekEditor.newDishesLinkLabel', 'Dishes'),
+  ('en', 'weekEditor.loadError', 'Loading failed: {message}'),
+  ('en', 'weekEditor.duplicateEntry', 'This dish is already assigned on this day.'),
+  ('en', 'weekEditor.saveError', 'Saving failed: {message}'),
+  ('en', 'weekEditor.deleteError', 'Deleting failed: {message}'),
+  ('en', 'dishManager.title', 'Dishes'),
+  ('en', 'dishManager.newDish', 'New dish'),
+  ('en', 'dishManager.editDish', 'Edit dish'),
+  ('en', 'dishManager.nameLabel', 'Name'),
+  ('en', 'dishManager.nameEnLabel', 'Name (English)'),
+  ('en', 'dishManager.namePlLabel', 'Name (Polish)'),
+  ('en', 'dishManager.autoTranslate', 'Auto-translate'),
+  ('en', 'dishManager.translating', 'Translating…'),
+  ('en', 'dishManager.translated', 'Translated.'),
+  ('en', 'dishManager.priceLabel', 'Price in €'),
+  ('en', 'dishManager.pricePlaceholder', '3.50'),
+  ('en', 'dishManager.searchPlaceholder', 'Search dishes…'),
+  ('en', 'dishManager.selectAll', 'Select all'),
+  ('en', 'dishManager.selectedCount', '{count} selected'),
+  ('en', 'dishManager.deleteSelected', 'Delete selected'),
+  ('en', 'dishManager.deleteSelectedCount', 'Delete selected ({count})'),
+  ('en', 'dishManager.empty', 'No dishes yet.'),
+  ('en', 'dishManager.noResults', 'No results for “{query}”.'),
+  ('en', 'dishManager.confirmDelete', 'Really delete “{name}”? The dish will also be removed from all weekly plans.'),
+  ('en', 'dishManager.confirmDeleteSelected', 'Really delete {count} dish(es)? They will also be removed from all weekly plans.'),
+  ('en', 'dishManager.invalidPrice', 'Please enter a valid price, e.g. 3.50'),
+  ('en', 'dishManager.loadError', 'Loading failed: {message}'),
+  ('en', 'dishManager.saveError', 'Saving failed: {message}'),
+  ('en', 'dishManager.deleteError', 'Deleting failed: {message}'),
+  ('en', 'dishManager.exportButton', 'Export'),
+  ('en', 'dishManager.importButton', 'Import'),
+  ('en', 'dishManager.exportError', 'Export failed: {message}'),
+  ('en', 'dishManager.importError', 'Import failed: {message}'),
+  ('en', 'dishManager.importSuccess', '{created} created, {updated} updated.'),
+  ('en', 'dishManager.importSkipped', '{count} row(s) skipped: {reasons}'),
+  ('en', 'dishManager.importSkippedRow', 'Row {row}: {reason}'),
+  ('en', 'dishManager.labelingDisabledHint', 'Allergens/additives are currently disabled (notice mode active, see "Allergens & additives").'),
+  ('en', 'codeList.allergensTitle', 'Allergens'),
+  ('en', 'codeList.additivesTitle', 'Additives'),
+  ('en', 'codeList.allergenCodeLabel', 'Code (e.g. A)'),
+  ('en', 'codeList.additiveCodeLabel', 'Code (e.g. 1)'),
+  ('en', 'codeList.nameLabel', 'Name'),
+  ('en', 'codeList.empty', 'No entries.'),
+  ('en', 'codeList.confirmDelete', 'Really delete “{code} – {name}”?'),
+  ('en', 'codeList.duplicateCode', 'The code “{code}” already exists.'),
+  ('en', 'codeList.loadError', 'Loading failed: {message}'),
+  ('en', 'codeList.saveError', 'Saving failed: {message}'),
+  ('en', 'codeList.deleteError', 'Deleting failed: {message}'),
+  ('en', 'codeList.exportButton', 'Export'),
+  ('en', 'codeList.importButton', 'Import'),
+  ('en', 'codeList.exportError', 'Export failed: {message}'),
+  ('en', 'codeList.importError', 'Import failed: {message}'),
+  ('en', 'codeList.importSuccess', '{created} created, {updated} updated.'),
+  ('en', 'codeList.importSkipped', '{count} row(s) skipped: {reasons}'),
+  ('en', 'codeList.importSkippedRow', 'Row {row}: {reason}'),
+  ('en', 'sectionManager.title', 'Meal times'),
+  ('en', 'sectionManager.newSection', 'New meal time'),
+  ('en', 'sectionManager.editSection', 'Edit meal time'),
+  ('en', 'sectionManager.nameLabel', 'Name'),
+  ('en', 'sectionManager.nameEnLabel', 'Name (English)'),
+  ('en', 'sectionManager.namePlLabel', 'Name (Polish)'),
+  ('en', 'sectionManager.timeFrom', 'From'),
+  ('en', 'sectionManager.timeTo', 'To'),
+  ('en', 'sectionManager.moveUp', 'Move up'),
+  ('en', 'sectionManager.moveDown', 'Move down'),
+  ('en', 'sectionManager.empty', 'No meal times yet.'),
+  ('en', 'sectionManager.confirmDelete', 'Really delete “{name}”? Assigned dishes will also be removed from all weekly plans.'),
+  ('en', 'sectionManager.loadError', 'Loading failed: {message}'),
+  ('en', 'sectionManager.saveError', 'Saving failed: {message}'),
+  ('en', 'sectionManager.deleteError', 'Deleting failed: {message}'),
+  ('en', 'userManager.title', 'Users'),
+  ('en', 'userManager.newUser', 'New user'),
+  ('en', 'userManager.editUser', 'Edit user'),
+  ('en', 'userManager.newPasswordLabel', 'New password (optional)'),
+  ('en', 'userManager.repeatPasswordLabel', 'Repeat password'),
+  ('en', 'userManager.passwordMismatch', 'The passwords do not match.'),
+  ('en', 'userManager.confirmDelete', 'Really delete user “{email}”? Access will be permanently removed.'),
+  ('en', 'userManager.loadError', 'Loading failed: {message}'),
+  ('en', 'designEditor.title', 'Design'),
+  ('en', 'designEditor.logoTitle', 'Logo'),
+  ('en', 'designEditor.logoHint', 'The logo is displayed centered above the menu.'),
+  ('en', 'designEditor.logoNone', 'No logo set.'),
+  ('en', 'designEditor.logoUpload', 'Upload logo'),
+  ('en', 'designEditor.logoRemove', 'Remove logo'),
+  ('en', 'designEditor.logoUpdated', 'Logo updated.'),
+  ('en', 'designEditor.logoRemoved', 'Logo removed.'),
+  ('en', 'designEditor.faviconTitle', 'Favicon'),
+  ('en', 'designEditor.faviconHint', 'Shown as the icon in the browser tab. Without a custom favicon, the application''s default icon is used.'),
+  ('en', 'designEditor.faviconNone', 'No custom favicon set.'),
+  ('en', 'designEditor.faviconUpload', 'Upload favicon'),
+  ('en', 'designEditor.faviconRemove', 'Remove favicon'),
+  ('en', 'designEditor.faviconUpdated', 'Favicon updated.'),
+  ('en', 'designEditor.faviconRemoved', 'Favicon removed.'),
+  ('en', 'designEditor.invalidImage', 'Please choose an image file (PNG, JPG, SVG, WebP, ICO).'),
+  ('en', 'designEditor.colorsTitle', 'Colors'),
+  ('en', 'designEditor.colorsSave', 'Save colors'),
+  ('en', 'designEditor.colorsReset', 'Reset to default'),
+  ('en', 'designEditor.colorsSaved', 'Colors saved.'),
+  ('en', 'designEditor.colorPrimary', 'Primary color (table header)'),
+  ('en', 'designEditor.colorPrimaryDark', 'Primary color, dark (internal top bar)'),
+  ('en', 'designEditor.colorAccent', 'Accent color'),
+  ('en', 'designEditor.colorHeaderText', 'Table header text color'),
+  ('en', 'designEditor.colorRowBg', 'Cell background'),
+  ('en', 'designEditor.colorRowBgAlt', 'Cell background (alternating)'),
+  ('en', 'designEditor.colorAddBtn', '“Add” button'),
+  ('en', 'designEditor.colorDeleteBtn', '“Delete” button'),
+  ('en', 'designEditor.loadError', 'Loading failed: {message}'),
+  ('en', 'designEditor.saveError', 'Saving failed: {message}'),
+  ('en', 'designEditor.uploadError', 'Upload failed: {message}'),
+  ('en', 'designEditor.confirmRemoveLogo', 'Really remove the logo?'),
+  ('en', 'designEditor.confirmRemoveFavicon', 'Really remove the favicon?'),
+  ('en', 'labelingNotice.title', 'Allergen & additive display'),
+  ('en', 'labelingNotice.hint', 'By default every guest sees a detailed allergen/additive selection per dish. Alternatively, only a notice text can be shown instead – the per-dish selection is then also hidden in the dish manager.'),
+  ('en', 'labelingNotice.modeDetailed', 'Show detailed selection per dish'),
+  ('en', 'labelingNotice.modeNotice', 'Show only notice text'),
+  ('en', 'labelingNotice.noticeDeLabel', 'Notice text (German)'),
+  ('en', 'labelingNotice.noticeEnLabel', 'Notice text (English)'),
+  ('en', 'labelingNotice.noticePlLabel', 'Notice text (Polish)'),
+  ('en', 'labelingNotice.save', 'Save'),
+  ('en', 'labelingNotice.saved', 'Saved.'),
+  ('en', 'labelingNotice.loadError', 'Loading failed: {message}'),
+  ('en', 'labelingNotice.saveError', 'Saving failed: {message}'),
+  ('en', 'passkeys.title', 'Passkeys'),
+  ('en', 'passkeys.hint', 'With a passkey (fingerprint, face recognition, or a security key) you can sign in without a password in the future. Passkeys are bound to a domain – after a domain change they need to be registered again.'),
+  ('en', 'passkeys.register', 'Register new passkey'),
+  ('en', 'passkeys.empty', 'No passkeys registered yet.'),
+  ('en', 'passkeys.createdOn', '– created on {date}'),
+  ('en', 'passkeys.registered', 'Passkey registered successfully.'),
+  ('en', 'passkeys.registerError', 'Registration failed: {message}'),
+  ('en', 'passkeys.registerCancelled', 'Passkey registration was cancelled.'),
+  ('en', 'passkeys.loadError', 'Could not load passkeys: {message}'),
+  ('en', 'passkeys.deleteError', 'Deleting failed: {message}'),
+  ('en', 'passkeys.confirmDelete', 'Really delete this passkey?'),
+  ('en', 'account.title', 'My account'),
+  ('en', 'account.personalTitle', 'Personal details'),
+  ('en', 'account.saveName', 'Save name'),
+  ('en', 'account.nameSaved', 'Name saved.'),
+  ('en', 'account.nameRequired', 'Please enter a name.'),
+  ('en', 'account.emailTitle', 'Email address'),
+  ('en', 'account.changeEmail', 'Change email address'),
+  ('en', 'account.emailChanged', 'Email address changed.'),
+  ('en', 'account.passwordTitle', 'Change password'),
+  ('en', 'account.currentPassword', 'Current password (for verification)'),
+  ('en', 'account.newPassword', 'New password'),
+  ('en', 'account.newPasswordRepeat', 'Repeat new password'),
+  ('en', 'account.changePassword', 'Change password'),
+  ('en', 'account.passwordChanged', 'Password changed.'),
+  ('en', 'account.passwordMismatch', 'The passwords do not match.'),
+  ('en', 'account.passwordTooShort', 'The new password must be at least 8 characters long.'),
+  ('en', 'account.passwordAuthTitle', 'Password sign-in'),
+  ('en', 'account.passwordAuthHint', 'You can disable email and password sign-in for your account and sign in exclusively with a passkey in the future. At least one passkey must be registered for this.'),
+  ('en', 'account.passwordAuthCheckbox', 'Email and password sign-in allowed'),
+  ('en', 'account.passwordAuthEnabled', 'Password sign-in enabled.'),
+  ('en', 'account.passwordAuthDisabled', 'Password sign-in disabled.'),
+  ('en', 'account.passwordAuthNeedsPasskey', 'You can''t disable password sign-in without a registered passkey – you would lock yourself out. Register a passkey below first.'),
+  ('en', 'account.confirmDisablePasswordAuth', 'Really disable email and password sign-in? Afterwards you can only sign in with a passkey.'),
+  ('en', 'account.wrongCurrentPassword', 'The current password is incorrect.'),
+  ('en', 'account.emailAlreadyUsed', 'This email address is already in use.'),
+  ('en', 'account.saveError', 'Saving failed: {message}'),
+  ('en', 'account.changeError', 'Change failed: {message}'),
+  ('en', 'suggestions.formTitle', 'Suggest a dish'),
+  ('en', 'suggestions.formHint', 'Missing a dish on the menu? Suggest it here – the canteen team will review your suggestion.'),
+  ('en', 'suggestions.nameLabel', 'Dish name'),
+  ('en', 'suggestions.descriptionLabel', 'Description / ingredients (optional)'),
+  ('en', 'suggestions.submit', 'Submit suggestion'),
+  ('en', 'suggestions.submitting', 'Submitting…'),
+  ('en', 'suggestions.success', 'Thanks! Your suggestion has been submitted.'),
+  ('en', 'suggestions.duplicate', 'This dish already exists on the menu.'),
+  ('en', 'suggestions.genericError', 'Submission failed: {message}'),
+  ('en', 'suggestions.nameRequired', 'Please enter a name.'),
+  ('en', 'suggestions.backToMenu', '← Back to menu'),
+  ('en', 'suggestions.reviewTitle', 'Dish suggestions'),
+  ('en', 'suggestions.reviewEmpty', 'No suggestions yet.'),
+  ('en', 'suggestions.accept', 'Add as dish'),
+  ('en', 'suggestions.reject', 'Reject'),
+  ('en', 'suggestions.confirmReject', 'Really reject and delete the suggestion “{name}”?'),
+  ('en', 'suggestions.accepted', 'Added as dish.'),
+  ('en', 'suggestions.rejected', 'Suggestion rejected.'),
+  ('en', 'suggestions.loadError', 'Loading failed: {message}'),
+  ('en', 'suggestions.actionError', 'Action failed: {message}'),
+  ('en', 'suggestions.submittedOn', 'submitted on {date}'),
+  ('en', 'languageManager.title', 'Languages'),
+  ('en', 'languageManager.hint', 'German is the fixed base language and always complete. Additional languages are imported as a translation file and automatically filled in with German wherever a term is missing.'),
+  ('en', 'languageManager.codeColumn', 'Code'),
+  ('en', 'languageManager.labelColumn', 'Display name'),
+  ('en', 'languageManager.activeColumn', 'Active'),
+  ('en', 'languageManager.completenessColumn', 'Completeness'),
+  ('en', 'languageManager.baseBadge', 'Base language'),
+  ('en', 'languageManager.complete', 'Complete'),
+  ('en', 'languageManager.completeness', '{percent}% translated'),
+  ('en', 'languageManager.outdated', '{count} new term(s) since last import'),
+  ('en', 'languageManager.downloadTemplate', 'Download template'),
+  ('en', 'languageManager.uploadTranslation', 'Upload translation'),
+  ('en', 'languageManager.newLanguageTitle', 'Add new language'),
+  ('en', 'languageManager.newLanguageCodeLabel', 'Language code (e.g. fr)'),
+  ('en', 'languageManager.newLanguageLabelLabel', 'Display name (e.g. Français)'),
+  ('en', 'languageManager.create', 'Create'),
+  ('en', 'languageManager.delete', 'Delete'),
+  ('en', 'languageManager.confirmDelete', 'Really delete “{label}”? All translations for this language will be lost.'),
+  ('en', 'languageManager.cannotDeleteBase', 'The base language cannot be deleted.'),
+  ('en', 'languageManager.cannotDeactivateLast', 'At least one language must stay active.'),
+  ('en', 'languageManager.loadError', 'Loading failed: {message}'),
+  ('en', 'languageManager.saveError', 'Saving failed: {message}'),
+  ('en', 'languageManager.deleteError', 'Deleting failed: {message}'),
+  ('en', 'languageManager.importSuccess', '{count} terms imported.'),
+  ('en', 'languageManager.importError', 'Import failed: {message}'),
+  ('en', 'languageManager.importInvalidFile', 'The file could not be read (invalid JSON).'),
+  ('en', 'languageManager.importMissingPlaceholder', '“{key}”: placeholder {placeholder} missing in the translation – row skipped.'),
+  ('en', 'languageManager.duplicateCode', 'The language code “{code}” already exists.'),
+  ('en', 'languageManager.invalidCode', 'Please enter a language code of 2-5 lowercase letters.');
+
+insert into ui_translations (language_code, key, value) values
+  ('pl', 'common.save', 'Zapisz'),
+  ('pl', 'common.cancel', 'Anuluj'),
+  ('pl', 'common.delete', 'Usuń'),
+  ('pl', 'common.edit', 'Edytuj'),
+  ('pl', 'common.add', 'Dodaj'),
+  ('pl', 'common.back', 'Wstecz'),
+  ('pl', 'common.login', 'Zaloguj się'),
+  ('pl', 'common.logout', 'Wyloguj się'),
+  ('pl', 'common.loading', 'Wczytywanie…'),
+  ('pl', 'common.you', '(ty)'),
+  ('pl', 'common.name', 'Nazwa'),
+  ('pl', 'common.email', 'Adres e-mail'),
+  ('pl', 'common.password', 'Hasło'),
+  ('pl', 'common.role', 'Rola'),
+  ('pl', 'common.roleAdmin', 'Administrator'),
+  ('pl', 'common.roleStaff', 'Personel stołówki'),
+  ('pl', 'weekdays.long.0', 'Poniedziałek'),
+  ('pl', 'weekdays.long.1', 'Wtorek'),
+  ('pl', 'weekdays.long.2', 'Środa'),
+  ('pl', 'weekdays.long.3', 'Czwartek'),
+  ('pl', 'weekdays.long.4', 'Piątek'),
+  ('pl', 'weekdays.short.0', 'Pon'),
+  ('pl', 'weekdays.short.1', 'Wto'),
+  ('pl', 'weekdays.short.2', 'Śro'),
+  ('pl', 'weekdays.short.3', 'Czw'),
+  ('pl', 'weekdays.short.4', 'Pią'),
+  ('pl', 'dateLocale', 'pl-PL'),
+  ('pl', 'header.canteen', 'Stołówka'),
+  ('pl', 'header.menuGroup', 'Jadłospis'),
+  ('pl', 'header.weekPlan', 'Plan tygodnia'),
+  ('pl', 'header.sections', 'Pory posiłków'),
+  ('pl', 'header.dishes', 'Dania'),
+  ('pl', 'header.labels', 'Alergeny i dodatki'),
+  ('pl', 'header.adminGroup', 'Administracja'),
+  ('pl', 'header.users', 'Użytkownicy'),
+  ('pl', 'header.design', 'Wygląd'),
+  ('pl', 'header.languages', 'Języki'),
+  ('pl', 'header.suggestions', 'Propozycje'),
+  ('pl', 'header.openSuggestions', '{count} otwartych propozycji dań'),
+  ('pl', 'header.viewMenu', 'Zobacz jadłospis'),
+  ('pl', 'header.myAccount', 'Moje konto'),
+  ('pl', 'header.menuToggle', 'Otwórz/zamknij menu'),
+  ('pl', 'login.title', 'Logowanie'),
+  ('pl', 'login.submit', 'Zaloguj się'),
+  ('pl', 'login.or', 'lub'),
+  ('pl', 'login.passkeyButton', 'Zaloguj się kluczem dostępu'),
+  ('pl', 'login.ssoButton', 'Zaloguj się przez Single Sign-On'),
+  ('pl', 'login.backToMenu', '← Powrót do jadłospisu'),
+  ('pl', 'login.errorInvalidCredentials', 'Nieprawidłowy adres e-mail lub hasło.'),
+  ('pl', 'login.errorPasskeyCancelled', 'Logowanie kluczem dostępu zostało anulowane.'),
+  ('pl', 'login.errorGeneric', 'Logowanie nie powiodło się: {message}'),
+  ('pl', 'login.errorPasswordDisabled', 'Logowanie hasłem jest wyłączone dla tego konta. Zaloguj się kluczem dostępu.'),
+  ('pl', 'login.errorOidcInvalidState', 'Logowanie SSO wygasło lub jest nieprawidłowe. Spróbuj ponownie.'),
+  ('pl', 'login.errorOidcUnknownUser', 'Nie istnieje konto dla tego adresu e-mail. Skontaktuj się z administracją.'),
+  ('pl', 'login.errorOidcFailed', 'Logowanie SSO nie powiodło się. Spróbuj ponownie.'),
+  ('pl', 'publicMenu.prevWeek', '← Poprzedni tydzień'),
+  ('pl', 'publicMenu.nextWeek', 'Następny tydzień →'),
+  ('pl', 'publicMenu.prevWeekShort', '← Tydzień'),
+  ('pl', 'publicMenu.nextWeekShort', 'Tydzień →'),
+  ('pl', 'publicMenu.today', 'Dziś'),
+  ('pl', 'publicMenu.dayTab', 'Dzień'),
+  ('pl', 'publicMenu.weekTab', 'Tydzień'),
+  ('pl', 'publicMenu.allergens', 'Alergeny'),
+  ('pl', 'publicMenu.additives', 'Dodatki'),
+  ('pl', 'publicMenu.labelingNoticeTitle', 'Alergeny i dodatki'),
+  ('pl', 'publicMenu.suggestDish', 'Zaproponuj danie'),
+  ('pl', 'publicMenu.noEntry', '–'),
+  ('pl', 'publicMenu.rssFeed', 'Subskrybuj kanał RSS'),
+  ('pl', 'weekEditor.title', 'Plan tygodnia'),
+  ('pl', 'weekEditor.loading', 'Wczytywanie planu tygodnia…'),
+  ('pl', 'weekEditor.changeDish', 'Wybierz inne danie'),
+  ('pl', 'weekEditor.addMeal', 'Dodaj posiłek'),
+  ('pl', 'weekEditor.newDishesHint', 'Nowe dania możesz dodać w zakładce {link}.'),
+  ('pl', 'weekEditor.newDishesLinkLabel', 'Dania'),
+  ('pl', 'weekEditor.loadError', 'Wczytywanie nie powiodło się: {message}'),
+  ('pl', 'weekEditor.duplicateEntry', 'To danie jest już przypisane na ten dzień.'),
+  ('pl', 'weekEditor.saveError', 'Zapisywanie nie powiodło się: {message}'),
+  ('pl', 'weekEditor.deleteError', 'Usuwanie nie powiodło się: {message}'),
+  ('pl', 'dishManager.title', 'Dania'),
+  ('pl', 'dishManager.newDish', 'Nowe danie'),
+  ('pl', 'dishManager.editDish', 'Edytuj danie'),
+  ('pl', 'dishManager.nameLabel', 'Nazwa'),
+  ('pl', 'dishManager.nameEnLabel', 'Nazwa (angielski)'),
+  ('pl', 'dishManager.namePlLabel', 'Nazwa (polski)'),
+  ('pl', 'dishManager.autoTranslate', 'Przetłumacz automatycznie'),
+  ('pl', 'dishManager.translating', 'Tłumaczenie…'),
+  ('pl', 'dishManager.translated', 'Przetłumaczono.'),
+  ('pl', 'dishManager.priceLabel', 'Cena w €'),
+  ('pl', 'dishManager.pricePlaceholder', '3,50'),
+  ('pl', 'dishManager.searchPlaceholder', 'Szukaj dania…'),
+  ('pl', 'dishManager.selectAll', 'Zaznacz wszystko'),
+  ('pl', 'dishManager.selectedCount', 'Zaznaczono: {count}'),
+  ('pl', 'dishManager.deleteSelected', 'Usuń zaznaczone'),
+  ('pl', 'dishManager.deleteSelectedCount', 'Usuń zaznaczone ({count})'),
+  ('pl', 'dishManager.empty', 'Nie dodano jeszcze żadnych dań.'),
+  ('pl', 'dishManager.noResults', 'Brak wyników dla „{query}”.'),
+  ('pl', 'dishManager.confirmDelete', 'Czy na pewno usunąć „{name}”? Danie zostanie również usunięte ze wszystkich planów tygodniowych.'),
+  ('pl', 'dishManager.confirmDeleteSelected', 'Czy na pewno usunąć {count} danie/dania? Zostaną również usunięte ze wszystkich planów tygodniowych.'),
+  ('pl', 'dishManager.invalidPrice', 'Podaj prawidłową cenę, np. 3,50'),
+  ('pl', 'dishManager.loadError', 'Wczytywanie nie powiodło się: {message}'),
+  ('pl', 'dishManager.saveError', 'Zapisywanie nie powiodło się: {message}'),
+  ('pl', 'dishManager.deleteError', 'Usuwanie nie powiodło się: {message}'),
+  ('pl', 'dishManager.exportButton', 'Eksportuj'),
+  ('pl', 'dishManager.importButton', 'Importuj'),
+  ('pl', 'dishManager.exportError', 'Eksport nie powiódł się: {message}'),
+  ('pl', 'dishManager.importError', 'Import nie powiódł się: {message}'),
+  ('pl', 'dishManager.importSuccess', 'Utworzono: {created}, zaktualizowano: {updated}.'),
+  ('pl', 'dishManager.importSkipped', 'Pominięto wierszy: {count}: {reasons}'),
+  ('pl', 'dishManager.importSkippedRow', 'Wiersz {row}: {reason}'),
+  ('pl', 'dishManager.labelingDisabledHint', 'Alergeny/dodatki są obecnie wyłączone (aktywny tryb komunikatu, patrz „Alergeny i dodatki”).'),
+  ('pl', 'codeList.allergensTitle', 'Alergeny'),
+  ('pl', 'codeList.additivesTitle', 'Dodatki'),
+  ('pl', 'codeList.allergenCodeLabel', 'Kod (np. A)'),
+  ('pl', 'codeList.additiveCodeLabel', 'Kod (np. 1)'),
+  ('pl', 'codeList.nameLabel', 'Nazwa'),
+  ('pl', 'codeList.empty', 'Brak wpisów.'),
+  ('pl', 'codeList.confirmDelete', 'Czy na pewno usunąć „{code} – {name}”?'),
+  ('pl', 'codeList.duplicateCode', 'Kod „{code}” już istnieje.'),
+  ('pl', 'codeList.loadError', 'Wczytywanie nie powiodło się: {message}'),
+  ('pl', 'codeList.saveError', 'Zapisywanie nie powiodło się: {message}'),
+  ('pl', 'codeList.deleteError', 'Usuwanie nie powiodło się: {message}'),
+  ('pl', 'codeList.exportButton', 'Eksportuj'),
+  ('pl', 'codeList.importButton', 'Importuj'),
+  ('pl', 'codeList.exportError', 'Eksport nie powiódł się: {message}'),
+  ('pl', 'codeList.importError', 'Import nie powiódł się: {message}'),
+  ('pl', 'codeList.importSuccess', 'Utworzono: {created}, zaktualizowano: {updated}.'),
+  ('pl', 'codeList.importSkipped', 'Pominięto wierszy: {count}: {reasons}'),
+  ('pl', 'codeList.importSkippedRow', 'Wiersz {row}: {reason}'),
+  ('pl', 'sectionManager.title', 'Pory posiłków'),
+  ('pl', 'sectionManager.newSection', 'Nowa pora posiłku'),
+  ('pl', 'sectionManager.editSection', 'Edytuj porę posiłku'),
+  ('pl', 'sectionManager.nameLabel', 'Nazwa'),
+  ('pl', 'sectionManager.nameEnLabel', 'Nazwa (angielski)'),
+  ('pl', 'sectionManager.namePlLabel', 'Nazwa (polski)'),
+  ('pl', 'sectionManager.timeFrom', 'Od'),
+  ('pl', 'sectionManager.timeTo', 'Do'),
+  ('pl', 'sectionManager.moveUp', 'Przesuń w górę'),
+  ('pl', 'sectionManager.moveDown', 'Przesuń w dół'),
+  ('pl', 'sectionManager.empty', 'Nie dodano jeszcze żadnych pór posiłków.'),
+  ('pl', 'sectionManager.confirmDelete', 'Czy na pewno usunąć „{name}”? Przypisane dania zostaną również usunięte ze wszystkich planów tygodniowych.'),
+  ('pl', 'sectionManager.loadError', 'Wczytywanie nie powiodło się: {message}'),
+  ('pl', 'sectionManager.saveError', 'Zapisywanie nie powiodło się: {message}'),
+  ('pl', 'sectionManager.deleteError', 'Usuwanie nie powiodło się: {message}'),
+  ('pl', 'userManager.title', 'Użytkownicy'),
+  ('pl', 'userManager.newUser', 'Nowy użytkownik'),
+  ('pl', 'userManager.editUser', 'Edytuj użytkownika'),
+  ('pl', 'userManager.newPasswordLabel', 'Nowe hasło (opcjonalnie)'),
+  ('pl', 'userManager.repeatPasswordLabel', 'Powtórz hasło'),
+  ('pl', 'userManager.passwordMismatch', 'Hasła nie są zgodne.'),
+  ('pl', 'userManager.confirmDelete', 'Czy na pewno usunąć użytkownika „{email}”? Dostęp zostanie trwale usunięty.'),
+  ('pl', 'userManager.loadError', 'Wczytywanie nie powiodło się: {message}'),
+  ('pl', 'designEditor.title', 'Wygląd'),
+  ('pl', 'designEditor.logoTitle', 'Logo'),
+  ('pl', 'designEditor.logoHint', 'Logo jest wyświetlane wyśrodkowane nad jadłospisem.'),
+  ('pl', 'designEditor.logoNone', 'Nie ustawiono logo.'),
+  ('pl', 'designEditor.logoUpload', 'Prześlij logo'),
+  ('pl', 'designEditor.logoRemove', 'Usuń logo'),
+  ('pl', 'designEditor.logoUpdated', 'Logo zaktualizowane.'),
+  ('pl', 'designEditor.logoRemoved', 'Logo usunięte.'),
+  ('pl', 'designEditor.faviconTitle', 'Favicon'),
+  ('pl', 'designEditor.faviconHint', 'Wyświetlane jako ikona na karcie przeglądarki. Bez własnego favicona używana jest domyślna ikona aplikacji.'),
+  ('pl', 'designEditor.faviconNone', 'Nie ustawiono własnego favicona.'),
+  ('pl', 'designEditor.faviconUpload', 'Prześlij favicon'),
+  ('pl', 'designEditor.faviconRemove', 'Usuń favicon'),
+  ('pl', 'designEditor.faviconUpdated', 'Favicon zaktualizowany.'),
+  ('pl', 'designEditor.faviconRemoved', 'Favicon usunięty.'),
+  ('pl', 'designEditor.invalidImage', 'Wybierz plik graficzny (PNG, JPG, SVG, WebP, ICO).'),
+  ('pl', 'designEditor.colorsTitle', 'Kolorystyka'),
+  ('pl', 'designEditor.colorsSave', 'Zapisz kolory'),
+  ('pl', 'designEditor.colorsReset', 'Przywróć domyślne'),
+  ('pl', 'designEditor.colorsSaved', 'Kolory zapisane.'),
+  ('pl', 'designEditor.colorPrimary', 'Kolor główny (nagłówek tabeli)'),
+  ('pl', 'designEditor.colorPrimaryDark', 'Kolor główny, ciemny (górny pasek wewnętrzny)'),
+  ('pl', 'designEditor.colorAccent', 'Kolor akcentu'),
+  ('pl', 'designEditor.colorHeaderText', 'Kolor tekstu w nagłówku tabeli'),
+  ('pl', 'designEditor.colorRowBg', 'Tło komórek'),
+  ('pl', 'designEditor.colorRowBgAlt', 'Tło komórek (naprzemienne)'),
+  ('pl', 'designEditor.colorAddBtn', 'Przycisk „Dodaj”'),
+  ('pl', 'designEditor.colorDeleteBtn', 'Przycisk „Usuń”'),
+  ('pl', 'designEditor.loadError', 'Wczytywanie nie powiodło się: {message}'),
+  ('pl', 'designEditor.saveError', 'Zapisywanie nie powiodło się: {message}'),
+  ('pl', 'designEditor.uploadError', 'Przesyłanie nie powiodło się: {message}'),
+  ('pl', 'designEditor.confirmRemoveLogo', 'Czy na pewno usunąć logo?'),
+  ('pl', 'designEditor.confirmRemoveFavicon', 'Czy na pewno usunąć favicon?'),
+  ('pl', 'labelingNotice.title', 'Wyświetlanie alergenów i dodatków'),
+  ('pl', 'labelingNotice.hint', 'Domyślnie każdy gość widzi szczegółowy wybór alergenów/dodatków dla każdego dania. Alternatywnie można zamiast tego wyświetlić tylko komunikat – wybór dla poszczególnych dań zostanie wtedy również ukryty w zarządzaniu daniami.'),
+  ('pl', 'labelingNotice.modeDetailed', 'Pokaż szczegółowy wybór dla każdego dania'),
+  ('pl', 'labelingNotice.modeNotice', 'Pokaż tylko komunikat'),
+  ('pl', 'labelingNotice.noticeDeLabel', 'Tekst komunikatu (niemiecki)'),
+  ('pl', 'labelingNotice.noticeEnLabel', 'Tekst komunikatu (angielski)'),
+  ('pl', 'labelingNotice.noticePlLabel', 'Tekst komunikatu (polski)'),
+  ('pl', 'labelingNotice.save', 'Zapisz'),
+  ('pl', 'labelingNotice.saved', 'Zapisano.'),
+  ('pl', 'labelingNotice.loadError', 'Wczytywanie nie powiodło się: {message}'),
+  ('pl', 'labelingNotice.saveError', 'Zapisywanie nie powiodło się: {message}'),
+  ('pl', 'passkeys.title', 'Klucze dostępu'),
+  ('pl', 'passkeys.hint', 'Dzięki kluczowi dostępu (odcisk palca, rozpoznawanie twarzy lub klucz bezpieczeństwa) możesz w przyszłości logować się bez hasła. Klucze dostępu są przypisane do domeny – po zmianie domeny trzeba je zarejestrować ponownie.'),
+  ('pl', 'passkeys.register', 'Zarejestruj nowy klucz dostępu'),
+  ('pl', 'passkeys.empty', 'Nie zarejestrowano jeszcze żadnych kluczy dostępu.'),
+  ('pl', 'passkeys.createdOn', '– utworzono {date}'),
+  ('pl', 'passkeys.registered', 'Klucz dostępu został pomyślnie zarejestrowany.'),
+  ('pl', 'passkeys.registerError', 'Rejestracja nie powiodła się: {message}'),
+  ('pl', 'passkeys.registerCancelled', 'Rejestracja klucza dostępu została anulowana.'),
+  ('pl', 'passkeys.loadError', 'Nie udało się wczytać kluczy dostępu: {message}'),
+  ('pl', 'passkeys.deleteError', 'Usuwanie nie powiodło się: {message}'),
+  ('pl', 'passkeys.confirmDelete', 'Czy na pewno usunąć ten klucz dostępu?'),
+  ('pl', 'account.title', 'Moje konto'),
+  ('pl', 'account.personalTitle', 'Dane osobowe'),
+  ('pl', 'account.saveName', 'Zapisz nazwę'),
+  ('pl', 'account.nameSaved', 'Nazwa zapisana.'),
+  ('pl', 'account.nameRequired', 'Podaj nazwę.'),
+  ('pl', 'account.emailTitle', 'Adres e-mail'),
+  ('pl', 'account.changeEmail', 'Zmień adres e-mail'),
+  ('pl', 'account.emailChanged', 'Adres e-mail zmieniony.'),
+  ('pl', 'account.passwordTitle', 'Zmień hasło'),
+  ('pl', 'account.currentPassword', 'Obecne hasło (do weryfikacji)'),
+  ('pl', 'account.newPassword', 'Nowe hasło'),
+  ('pl', 'account.newPasswordRepeat', 'Powtórz nowe hasło'),
+  ('pl', 'account.changePassword', 'Zmień hasło'),
+  ('pl', 'account.passwordChanged', 'Hasło zmienione.'),
+  ('pl', 'account.passwordMismatch', 'Hasła nie są zgodne.'),
+  ('pl', 'account.passwordTooShort', 'Nowe hasło musi mieć co najmniej 8 znaków.'),
+  ('pl', 'account.passwordAuthTitle', 'Logowanie hasłem'),
+  ('pl', 'account.passwordAuthHint', 'Możesz wyłączyć logowanie e-mailem i hasłem dla swojego konta i logować się w przyszłości wyłącznie kluczem dostępu. Wymaga to zarejestrowania co najmniej jednego klucza dostępu.'),
+  ('pl', 'account.passwordAuthCheckbox', 'Logowanie e-mailem i hasłem dozwolone'),
+  ('pl', 'account.passwordAuthEnabled', 'Logowanie hasłem włączone.'),
+  ('pl', 'account.passwordAuthDisabled', 'Logowanie hasłem wyłączone.'),
+  ('pl', 'account.passwordAuthNeedsPasskey', 'Bez zarejestrowanego klucza dostępu nie możesz wyłączyć logowania hasłem – stracisz dostęp do konta. Najpierw zarejestruj klucz dostępu poniżej.'),
+  ('pl', 'account.confirmDisablePasswordAuth', 'Czy na pewno wyłączyć logowanie e-mailem i hasłem? Potem będziesz mógł/mogła zalogować się tylko kluczem dostępu.'),
+  ('pl', 'account.wrongCurrentPassword', 'Obecne hasło jest nieprawidłowe.'),
+  ('pl', 'account.emailAlreadyUsed', 'Ten adres e-mail jest już używany.'),
+  ('pl', 'account.saveError', 'Zapisywanie nie powiodło się: {message}'),
+  ('pl', 'account.changeError', 'Zmiana nie powiodła się: {message}'),
+  ('pl', 'suggestions.formTitle', 'Zaproponuj danie'),
+  ('pl', 'suggestions.formHint', 'Brakuje dania w jadłospisie? Zaproponuj je tutaj – zespół stołówki sprawdzi Twoją propozycję.'),
+  ('pl', 'suggestions.nameLabel', 'Nazwa dania'),
+  ('pl', 'suggestions.descriptionLabel', 'Opis / składniki (opcjonalnie)'),
+  ('pl', 'suggestions.submit', 'Wyślij propozycję'),
+  ('pl', 'suggestions.submitting', 'Wysyłanie…'),
+  ('pl', 'suggestions.success', 'Dziękujemy! Twoja propozycja została przesłana.'),
+  ('pl', 'suggestions.duplicate', 'To danie już istnieje w jadłospisie.'),
+  ('pl', 'suggestions.genericError', 'Wysyłanie nie powiodło się: {message}'),
+  ('pl', 'suggestions.nameRequired', 'Podaj nazwę.'),
+  ('pl', 'suggestions.backToMenu', '← Powrót do jadłospisu'),
+  ('pl', 'suggestions.reviewTitle', 'Propozycje dań'),
+  ('pl', 'suggestions.reviewEmpty', 'Brak propozycji.'),
+  ('pl', 'suggestions.accept', 'Dodaj jako danie'),
+  ('pl', 'suggestions.reject', 'Odrzuć'),
+  ('pl', 'suggestions.confirmReject', 'Czy na pewno odrzucić i usunąć propozycję „{name}”?'),
+  ('pl', 'suggestions.accepted', 'Dodano jako danie.'),
+  ('pl', 'suggestions.rejected', 'Propozycja odrzucona.'),
+  ('pl', 'suggestions.loadError', 'Wczytywanie nie powiodło się: {message}'),
+  ('pl', 'suggestions.actionError', 'Czynność nie powiodła się: {message}'),
+  ('pl', 'suggestions.submittedOn', 'przesłano {date}'),
+  ('pl', 'languageManager.title', 'Języki'),
+  ('pl', 'languageManager.hint', 'Niemiecki jest stałym językiem bazowym i zawsze kompletny. Kolejne języki są importowane jako plik tłumaczenia i automatycznie uzupełniane niemieckim tekstem tam, gdzie brakuje tłumaczenia.'),
+  ('pl', 'languageManager.codeColumn', 'Kod'),
+  ('pl', 'languageManager.labelColumn', 'Nazwa wyświetlana'),
+  ('pl', 'languageManager.activeColumn', 'Aktywny'),
+  ('pl', 'languageManager.completenessColumn', 'Kompletność'),
+  ('pl', 'languageManager.baseBadge', 'Język bazowy'),
+  ('pl', 'languageManager.complete', 'Kompletny'),
+  ('pl', 'languageManager.completeness', 'Przetłumaczono {percent}%'),
+  ('pl', 'languageManager.outdated', 'Nowe terminy od ostatniego importu: {count}'),
+  ('pl', 'languageManager.downloadTemplate', 'Pobierz szablon'),
+  ('pl', 'languageManager.uploadTranslation', 'Prześlij tłumaczenie'),
+  ('pl', 'languageManager.newLanguageTitle', 'Dodaj nowy język'),
+  ('pl', 'languageManager.newLanguageCodeLabel', 'Kod języka (np. fr)'),
+  ('pl', 'languageManager.newLanguageLabelLabel', 'Nazwa wyświetlana (np. Français)'),
+  ('pl', 'languageManager.create', 'Utwórz'),
+  ('pl', 'languageManager.delete', 'Usuń'),
+  ('pl', 'languageManager.confirmDelete', 'Czy na pewno usunąć „{label}”? Wszystkie tłumaczenia tego języka zostaną utracone.'),
+  ('pl', 'languageManager.cannotDeleteBase', 'Nie można usunąć języka bazowego.'),
+  ('pl', 'languageManager.cannotDeactivateLast', 'Co najmniej jeden język musi pozostać aktywny.'),
+  ('pl', 'languageManager.loadError', 'Wczytywanie nie powiodło się: {message}'),
+  ('pl', 'languageManager.saveError', 'Zapisywanie nie powiodło się: {message}'),
+  ('pl', 'languageManager.deleteError', 'Usuwanie nie powiodło się: {message}'),
+  ('pl', 'languageManager.importSuccess', 'Zaimportowano terminów: {count}.'),
+  ('pl', 'languageManager.importError', 'Import nie powiódł się: {message}'),
+  ('pl', 'languageManager.importInvalidFile', 'Nie można odczytać pliku (nieprawidłowy JSON).'),
+  ('pl', 'languageManager.importMissingPlaceholder', '„{key}”: brak symbolu zastępczego {placeholder} w tłumaczeniu – wiersz pominięto.'),
+  ('pl', 'languageManager.duplicateCode', 'Kod języka „{code}” już istnieje.'),
+  ('pl', 'languageManager.invalidCode', 'Podaj kod języka złożony z 2–5 małych liter.');
@@ -0,0 +1,71 @@
+-- Teil 2 des "mehrsprachig variabel"-Umbaus: Speiseplan-Inhalte
+-- (Gerichte, Essenszeiten, Allergene, Zusatzstoffe) bekommen eine
+-- Übersetzungstabelle je Ressource statt fester name_en/name_pl-
+-- Spalten (Teil 1, v1.10.0, hat dasselbe schon für die
+-- Bedienoberfläche gemacht). Deutsch bleibt die Basis-Spalte
+-- (name/label) auf der jeweiligen Haupttabelle.
+--
+-- WICHTIG bei Deployments mit echten Daten: vor dem Einspielen ein
+-- Backup ziehen (siehe DEPLOYMENT.md, Abschnitt "Backup") – Schritt 3
+-- entfernt die alten name_en/name_pl-Spalten unwiderruflich, nachdem
+-- Schritt 2 ihren Inhalt in die neuen Tabellen übernommen hat.
+
+-- ---------- Schritt 1: neue Tabellen ----------
+create table dish_translations (
+  dish_id       uuid not null references dishes(id) on delete cascade,
+  language_code text not null references languages(code) on delete cascade,
+  name          text not null,
+  primary key (dish_id, language_code)
+);
+
+create table section_translations (
+  section_key   text not null references sections(key) on delete cascade,
+  language_code text not null references languages(code) on delete cascade,
+  name          text not null,
+  primary key (section_key, language_code)
+);
+
+-- allergens.code/additives.code sind vom Admin umbenennbar (Primary
+-- Key), anders als dishes.id/sections.key – "on update cascade" nötig,
+-- damit eine Umbenennung des Kürzels nicht die Übersetzungszeilen
+-- verwaist.
+create table allergen_translations (
+  allergen_code text not null references allergens(code) on delete cascade on update cascade,
+  language_code text not null references languages(code) on delete cascade,
+  name          text not null,
+  primary key (allergen_code, language_code)
+);
+
+create table additive_translations (
+  additive_code text not null references additives(code) on delete cascade on update cascade,
+  language_code text not null references languages(code) on delete cascade,
+  name          text not null,
+  primary key (additive_code, language_code)
+);
+
+-- ---------- Schritt 2: bestehende Übersetzungen übernehmen ----------
+insert into dish_translations (dish_id, language_code, name)
+select id, 'en', name_en from dishes where name_en is not null and trim(name_en) != '';
+insert into dish_translations (dish_id, language_code, name)
+select id, 'pl', name_pl from dishes where name_pl is not null and trim(name_pl) != '';
+
+insert into section_translations (section_key, language_code, name)
+select key, 'en', label_en from sections where label_en is not null and trim(label_en) != '';
+insert into section_translations (section_key, language_code, name)
+select key, 'pl', label_pl from sections where label_pl is not null and trim(label_pl) != '';
+
+insert into allergen_translations (allergen_code, language_code, name)
+select code, 'en', name_en from allergens where name_en is not null and trim(name_en) != '';
+insert into allergen_translations (allergen_code, language_code, name)
+select code, 'pl', name_pl from allergens where name_pl is not null and trim(name_pl) != '';
+
+insert into additive_translations (additive_code, language_code, name)
+select code, 'en', name_en from additives where name_en is not null and trim(name_en) != '';
+insert into additive_translations (additive_code, language_code, name)
+select code, 'pl', name_pl from additives where name_pl is not null and trim(name_pl) != '';
+
+-- ---------- Schritt 3: alte Spalten entfernen ----------
+alter table dishes drop column name_en, drop column name_pl;
+alter table sections drop column label_en, drop column label_pl;
+alter table allergens drop column name_en, drop column name_pl;
+alter table additives drop column name_en, drop column name_pl;
@@ -0,0 +1,18 @@
+-- Kantine an einzelnen Tagen als geschlossen markieren (Feiertage o. Ä.),
+-- mit optionalem, mehrsprachigem Grund. Ein Tag ohne Zeile hier gilt als
+-- regulär geöffnet.
+create table closed_days (
+  closed_date date primary key,
+  reason      text,
+  created_at  timestamptz not null default now()
+);
+
+-- Wert-Spalte heißt bewusst "name" (nicht "reason"), damit die generische
+-- Zugriffsschicht in lib/db/translations.ts unverändert funktioniert –
+-- dieselbe Konvention wie bei section_translations.name für sections.label.
+create table closed_day_translations (
+  closed_date   date not null references closed_days(closed_date) on delete cascade,
+  language_code text not null references languages(code) on delete cascade,
+  name          text not null,
+  primary key (closed_date, language_code)
+);
@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// Spielt db/seed-demo.sql ein: ersetzt Essenszeiten/Gerichte/Allergene/
+// Zusatzstoffe/Wochenplan durch den Beispieldatensatz. Nur für lokale
+// Entwicklung/Demos gedacht, läuft nicht automatisch beim Start.
+
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import pg from "pg";
+
+const sql = readFileSync(
+  join(dirname(fileURLToPath(import.meta.url)), "seed-demo.sql"),
+  "utf8"
+);
+
+async function main() {
+  const client = new pg.Client({ connectionString: process.env.DATABASE_URL });
+  await client.connect();
+  try {
+    await client.query(sql);
+    console.log("db:seed-demo – Beispieldaten eingespielt.");
+  } finally {
+    await client.end();
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
@@ -0,0 +1,169 @@
+-- =============================================================
+-- Beispieldaten für die lokale Entwicklung/Demo (NICHT Teil der
+-- automatischen Migrationen – frische Deployments starten bewusst
+-- leer, s. db/migrations/0001_init.sql). Manuell anwendbar über
+-- "npm run db:seed-demo".
+--
+-- Ersetzt vorhandene Essenszeiten/Gerichte/Allergene/Zusatzstoffe/
+-- Wochenplan-Einträge durch den ursprünglichen Beispieldatensatz.
+-- =============================================================
+
+delete from menu_entries;
+delete from dish_suggestions;
+delete from dishes;
+delete from sections;
+delete from allergens;
+delete from additives;
+
+-- ---------- Essenszeiten ----------
+insert into sections (key, label, time_range, sort) values
+  ('brotzeit',        'Brotzeit',                '09:00 - 10:00', 1),
+  ('mittagessen',     'Mittagessen',              '11:30 - 13:30', 2),
+  ('mittagessen_veg', 'Mittagessen vegetarisch',  '11:30 - 13:30', 3),
+  ('suppe',           'Suppe',                    '11:30 - 13:30', 4);
+
+insert into section_translations (section_key, language_code, name) values
+  ('brotzeit',        'en', 'Breakfast'),
+  ('brotzeit',        'pl', 'Śniadanie'),
+  ('mittagessen',     'en', 'Lunch'),
+  ('mittagessen',     'pl', 'Obiad'),
+  ('mittagessen_veg', 'en', 'Lunch (vegetarian)'),
+  ('mittagessen_veg', 'pl', 'Obiad (wegetariański)'),
+  ('suppe',           'en', 'Soup'),
+  ('suppe',           'pl', 'Zupa');
+
+-- ---------- Allergene (EU-Kennzeichnung, Buchstaben) ----------
+insert into allergens (code, name, sort) values
+  ('A', 'Glutenhaltiges Getreide',        1),
+  ('B', 'Krebstiere',                     2),
+  ('C', 'Eier',                           3),
+  ('D', 'Fisch',                          4),
+  ('E', 'Erdnüsse',                       5),
+  ('F', 'Sojabohnen',                     6),
+  ('G', 'Milch (einschließlich Laktose)', 7),
+  ('H', 'Schalenfrüchte (Nüsse)',         8),
+  ('I', 'Sellerie',                       9),
+  ('J', 'Senf',                          10),
+  ('K', 'Sesamsamen',                    11),
+  ('L', 'Schwefeldioxid und Sulfite',    12),
+  ('M', 'Lupinen',                       13),
+  ('N', 'Weichtiere',                    14);
+
+insert into allergen_translations (allergen_code, language_code, name) values
+  ('A', 'en', 'Cereals containing gluten'),      ('A', 'pl', 'Zboża zawierające gluten'),
+  ('B', 'en', 'Crustaceans'),                    ('B', 'pl', 'Skorupiaki'),
+  ('C', 'en', 'Eggs'),                           ('C', 'pl', 'Jaja'),
+  ('D', 'en', 'Fish'),                           ('D', 'pl', 'Ryby'),
+  ('E', 'en', 'Peanuts'),                        ('E', 'pl', 'Orzeszki ziemne'),
+  ('F', 'en', 'Soybeans'),                       ('F', 'pl', 'Soja'),
+  ('G', 'en', 'Milk (including lactose)'),       ('G', 'pl', 'Mleko (w tym laktoza)'),
+  ('H', 'en', 'Tree nuts'),                      ('H', 'pl', 'Orzechy'),
+  ('I', 'en', 'Celery'),                         ('I', 'pl', 'Seler'),
+  ('J', 'en', 'Mustard'),                        ('J', 'pl', 'Gorczyca'),
+  ('K', 'en', 'Sesame seeds'),                   ('K', 'pl', 'Nasiona sezamu'),
+  ('L', 'en', 'Sulphur dioxide and sulphites'),  ('L', 'pl', 'Dwutlenek siarki i siarczyny'),
+  ('M', 'en', 'Lupin'),                          ('M', 'pl', 'Łubin'),
+  ('N', 'en', 'Molluscs'),                       ('N', 'pl', 'Mięczaki');
+
+-- ---------- Zusatzstoffe (Ziffern) ----------
+insert into additives (code, name, sort) values
+  ('1',  'mit Farbstoff',                    1),
+  ('2',  'mit Konservierungsstoff',          2),
+  ('3',  'mit Antioxidationsmittel',         3),
+  ('4',  'mit Geschmacksverstärker',         4),
+  ('5',  'geschwefelt',                      5),
+  ('6',  'geschwärzt',                       6),
+  ('7',  'gewachst',                         7),
+  ('8',  'mit Phosphat',                     8),
+  ('9',  'mit Süßungsmittel(n)',             9),
+  ('10', 'enthält eine Phenylalaninquelle', 10),
+  ('11', 'koffeinhaltig',                   11);
+
+insert into additive_translations (additive_code, language_code, name) values
+  ('1',  'en', 'with colouring'),                     ('1',  'pl', 'z barwnikiem'),
+  ('2',  'en', 'with preservative'),                  ('2',  'pl', 'z konserwantem'),
+  ('3',  'en', 'with antioxidant'),                   ('3',  'pl', 'z przeciwutleniaczem'),
+  ('4',  'en', 'with flavour enhancer'),               ('4',  'pl', 'ze wzmacniaczem smaku'),
+  ('5',  'en', 'sulphured'),                           ('5',  'pl', 'siarkowany'),
+  ('6',  'en', 'blackened'),                           ('6',  'pl', 'barwiony na czarno'),
+  ('7',  'en', 'waxed'),                               ('7',  'pl', 'woskowany'),
+  ('8',  'en', 'with phosphate'),                      ('8',  'pl', 'z fosforanem'),
+  ('9',  'en', 'with sweetener(s)'),                   ('9',  'pl', 'ze słodzikiem/słodzikami'),
+  ('10', 'en', 'contains a source of phenylalanine'),  ('10', 'pl', 'zawiera źródło fenyloalaniny'),
+  ('11', 'en', 'caffeinated'),                         ('11', 'pl', 'zawiera kofeinę');
+
+-- ---------- Testgerichte ----------
+insert into dishes (name, price) values
+  -- Brotzeit
+  ('1 Stk. Rindskäsewurst mit Brötchen',                              2.30),
+  ('Hackfleischbaguette',                                             3.20),
+  ('Knusperhähnchen Wrap',                                            3.70),
+  ('Leberkäse im Brötchen',                                           2.30),
+  ('Chili con Carne mit Brötchen',                                    3.90),
+  -- Mittagessen
+  ('Schnitzel Baguette',                                              3.50),
+  ('Penne mit Grünen Spargel und Garnelenspieße',                     5.90),
+  ('Bratkartoffel Gemüse Pfanne mit Hähnchenbrust und Dip',           5.90),
+  ('Schweinefilet im Speckmantel dazu Rahmsoße und Butterspätzle',    5.90),
+  -- Mittagessen vegetarisch
+  ('Penne mit Grünen Spargel, get. Tomaten und Cherrytomaten',        5.30),
+  ('Spaghetti mit fruchtiger Tomatensauce und Parmesan',              5.30),
+  ('Gebackener Feta mit griechischen Bauernsalat und Baguette',       5.30),
+  ('Gemüse-Curry mit Basmatireis',                                    4.90),
+  -- Suppen
+  ('Kartoffelcremesuppe',                                             1.50),
+  ('Gulaschsuppe',                                                    2.50),
+  ('Tomatensuppe mit Croutons',                                       1.80),
+  ('Kürbiscremesuppe',                                                1.80),
+  ('Linseneintopf mit Würstchen',                                     2.20);
+
+-- ---------- Beispielwoche 13.–17. Juli 2026 ----------
+with d as (select id, name from dishes)
+insert into menu_entries (menu_date, section_key, dish_id)
+select x.menu_date::date, x.section_key, d.id
+from (values
+  ('2026-07-13', 'brotzeit',        '1 Stk. Rindskäsewurst mit Brötchen'),
+  ('2026-07-14', 'brotzeit',        'Hackfleischbaguette'),
+  ('2026-07-15', 'brotzeit',        'Knusperhähnchen Wrap'),
+  ('2026-07-16', 'brotzeit',        'Leberkäse im Brötchen'),
+  ('2026-07-17', 'brotzeit',        'Chili con Carne mit Brötchen'),
+  ('2026-07-13', 'mittagessen',     'Schnitzel Baguette'),
+  ('2026-07-14', 'mittagessen',     'Penne mit Grünen Spargel und Garnelenspieße'),
+  ('2026-07-15', 'mittagessen',     'Bratkartoffel Gemüse Pfanne mit Hähnchenbrust und Dip'),
+  ('2026-07-16', 'mittagessen',     'Schweinefilet im Speckmantel dazu Rahmsoße und Butterspätzle'),
+  ('2026-07-14', 'mittagessen_veg', 'Penne mit Grünen Spargel, get. Tomaten und Cherrytomaten'),
+  ('2026-07-15', 'mittagessen_veg', 'Spaghetti mit fruchtiger Tomatensauce und Parmesan'),
+  ('2026-07-16', 'mittagessen_veg', 'Gebackener Feta mit griechischen Bauernsalat und Baguette'),
+  ('2026-07-13', 'suppe',           'Kartoffelcremesuppe'),
+  ('2026-07-14', 'suppe',           'Gulaschsuppe'),
+  ('2026-07-15', 'suppe',           'Tomatensuppe mit Croutons'),
+  ('2026-07-16', 'suppe',           'Kürbiscremesuppe'),
+  ('2026-07-17', 'suppe',           'Linseneintopf mit Würstchen')
+) as x (menu_date, section_key, name)
+join d on d.name = x.name;
+
+-- ---------- Beispielwoche 20.–24. Juli 2026 ("Nächste Woche") ----------
+with d as (select id, name from dishes)
+insert into menu_entries (menu_date, section_key, dish_id)
+select x.menu_date::date, x.section_key, d.id
+from (values
+  ('2026-07-20', 'brotzeit',        'Leberkäse im Brötchen'),
+  ('2026-07-21', 'brotzeit',        'Knusperhähnchen Wrap'),
+  ('2026-07-22', 'brotzeit',        '1 Stk. Rindskäsewurst mit Brötchen'),
+  ('2026-07-23', 'brotzeit',        'Hackfleischbaguette'),
+  ('2026-07-24', 'brotzeit',        'Chili con Carne mit Brötchen'),
+  ('2026-07-20', 'mittagessen',     'Bratkartoffel Gemüse Pfanne mit Hähnchenbrust und Dip'),
+  ('2026-07-21', 'mittagessen',     'Schweinefilet im Speckmantel dazu Rahmsoße und Butterspätzle'),
+  ('2026-07-22', 'mittagessen',     'Schnitzel Baguette'),
+  ('2026-07-23', 'mittagessen',     'Penne mit Grünen Spargel und Garnelenspieße'),
+  ('2026-07-20', 'mittagessen_veg', 'Gemüse-Curry mit Basmatireis'),
+  ('2026-07-21', 'mittagessen_veg', 'Spaghetti mit fruchtiger Tomatensauce und Parmesan'),
+  ('2026-07-22', 'mittagessen_veg', 'Gebackener Feta mit griechischen Bauernsalat und Baguette'),
+  ('2026-07-23', 'mittagessen_veg', 'Penne mit Grünen Spargel, get. Tomaten und Cherrytomaten'),
+  ('2026-07-20', 'suppe',           'Gulaschsuppe'),
+  ('2026-07-21', 'suppe',           'Kartoffelcremesuppe'),
+  ('2026-07-22', 'suppe',           'Linseneintopf mit Würstchen'),
+  ('2026-07-23', 'suppe',           'Tomatensuppe mit Croutons'),
+  ('2026-07-24', 'suppe',           'Kürbiscremesuppe')
+) as x (menu_date, section_key, name)
+join d on d.name = x.name;
@@ -1,15 +1,12 @@
 # =============================================================
 # Canteen Menu – Docker-Setup
 #
-# Produktion (App + lokale PostgreSQL-Kopie):
+# Produktion (App + PostgreSQL):
 #   docker compose --env-file .env.local up -d --build
 #
 # Entwicklung (Dev-Server mit Hot-Reload, kein lokales Node nötig):
 #   docker compose --env-file .env.local --profile dev up dev
 #
-# Die --env-file-Angabe speist NEXT_PUBLIC_* in den Build und
-# SUPABASE_SERVICE_ROLE_KEY in die Laufzeit-Umgebung.
-#
 # "name" fixiert den Compose-Projektnamen explizit auf "canteen-menu" –
 # ohne diese Angabe leitet Compose ihn aus dem Ordnernamen ab.
 # =============================================================
@@ -21,39 +18,57 @@ services:
  app:
    build:
      context: .
-      args:
-        NEXT_PUBLIC_SUPABASE_URL: ${NEXT_PUBLIC_SUPABASE_URL}
-        NEXT_PUBLIC_SUPABASE_ANON_KEY: ${NEXT_PUBLIC_SUPABASE_ANON_KEY}
    image: canteen-menu-app
    container_name: canteen-menu-app
    environment:
-      NEXT_PUBLIC_SUPABASE_URL: ${NEXT_PUBLIC_SUPABASE_URL}
-      NEXT_PUBLIC_SUPABASE_ANON_KEY: ${NEXT_PUBLIC_SUPABASE_ANON_KEY}
-      SUPABASE_SERVICE_ROLE_KEY: ${SUPABASE_SERVICE_ROLE_KEY}
+      DATABASE_URL: postgres://postgres:${LOCAL_PG_PASSWORD:-canteen_menu}@db:5432/canteen_menu
      # Öffentliche URL der App (Domain hinter dem Reverse-Proxy).
-      # Wird für den CSRF-Origin-Check genutzt; dieselbe URL ist die
-      # Passkey-Domain (siehe scripts/configure-passkeys.mjs).
+      # Wird für den CSRF-Origin-Check genutzt; dieselbe URL ist auch die
+      # Passkey-Domain (RP-ID/Origin werden direkt daraus abgeleitet).
      APP_URL: ${APP_URL:-http://localhost:3000}
+      # Titel im Browser-Tab und Überschrift, solange kein Logo hochgeladen ist.
+      SITE_TITLE: ${SITE_TITLE:-Canteen Menu}
+      # Optional: E-Mail des automatisch angelegten Admin-Erstnutzers.
+      ADMIN_EMAIL: ${ADMIN_EMAIL:-}
+      # Optional: DeepL-API-Key für automatische Übersetzung von Gerichten
+      # (Essenszeiten, Kürzel-Erklärungen) nach Englisch/Polnisch. Ohne Key
+      # bleibt "Automatisch übersetzen" inaktiv, manuelle Eingabe geht immer.
+      DEEPL_API_KEY: ${DEEPL_API_KEY:-}
+      # Optional: SSO-Login per OpenID Connect (z. B. Authentik). Ohne
+      # diese drei Werte bleibt der SSO-Button ausgeblendet. Funktioniert
+      # nur für bereits angelegte Benutzer (Abgleich per E-Mail), legt nie
+      # neue Konten an.
+      OIDC_ISSUER: ${OIDC_ISSUER:-}
+      OIDC_CLIENT_ID: ${OIDC_CLIENT_ID:-}
+      OIDC_CLIENT_SECRET: ${OIDC_CLIENT_SECRET:-}
+      # Muss auf das "volumes:"-Ziel unten UND das im Dockerfile per
+      # "mkdir/chown" vorbereitete Verzeichnis zeigen – ohne diese
+      # Variable würde lib/branding.ts auf ${PWD}/data/branding
+      # zurückfallen, das weder gemountet noch für den nicht-root
+      # App-Nutzer beschreibbar ist (Upload schlägt mit 500 fehl).
+      BRANDING_DIR: /data/branding
    ports:
      - "0.0.0.0:3000:3000"
+    volumes:
+      - branding_data:/data/branding
+      - ./ZUGANGSDATEN.md:/app/ZUGANGSDATEN.md
+    depends_on:
+      - db
    restart: unless-stopped

-  # ---------- Lokale PostgreSQL-Kopie (Ablage/Auswertungen) ----------
-  # Beim ersten Start werden die Skripte aus supabase/local
-  # automatisch in alphabetischer Reihenfolge eingespielt.
+  # ---------- PostgreSQL (primäre Datenbank) ----------
  db:
    image: postgres:17-alpine
    container_name: canteen-menu-db
    environment:
      POSTGRES_DB: canteen_menu
      POSTGRES_PASSWORD: ${LOCAL_PG_PASSWORD:-canteen_menu}
-    ports:
-      # Host-Port 5433, da 5432 meist schon von einer nativen
-      # PostgreSQL-Installation belegt ist.
-      - "5433:5432"
+    # Bewusst kein "ports:"-Mapping: die Datenbank ist nur innerhalb des
+    # Compose-Netzwerks unter "db:5432" erreichbar (für app/dev), nicht
+    # vom Host oder von außen. Zugriff für Debugging/Backups über
+    # "docker compose exec db psql -U postgres canteen_menu".
    volumes:
      - pgdata:/var/lib/postgresql/data
-      - ./supabase/local:/docker-entrypoint-initdb.d:ro
    restart: unless-stopped

  # ---------- Dev-Server (nur mit --profile dev) ----------
@@ -64,16 +79,24 @@ services:
    working_dir: /app
    command: sh -c "npm install && npm run dev"
    environment:
-      NEXT_PUBLIC_SUPABASE_URL: ${NEXT_PUBLIC_SUPABASE_URL}
-      NEXT_PUBLIC_SUPABASE_ANON_KEY: ${NEXT_PUBLIC_SUPABASE_ANON_KEY}
-      SUPABASE_SERVICE_ROLE_KEY: ${SUPABASE_SERVICE_ROLE_KEY}
+      DATABASE_URL: postgres://postgres:${LOCAL_PG_PASSWORD:-canteen_menu}@db:5432/canteen_menu
      APP_URL: ${APP_URL:-http://localhost:3000}
+      SITE_TITLE: ${SITE_TITLE:-Canteen Menu}
+      ADMIN_EMAIL: ${ADMIN_EMAIL:-}
+      DEEPL_API_KEY: ${DEEPL_API_KEY:-}
+      OIDC_ISSUER: ${OIDC_ISSUER:-}
+      OIDC_CLIENT_ID: ${OIDC_CLIENT_ID:-}
+      OIDC_CLIENT_SECRET: ${OIDC_CLIENT_SECRET:-}
    ports:
      - "0.0.0.0:3000:3000"
    volumes:
      - .:/app
      - dev_node_modules:/app/node_modules
+      - branding_data:/app/data/branding
+    depends_on:
+      - db

 volumes:
  pgdata:
  dev_node_modules:
+  branding_data:
@@ -0,0 +1,99 @@
+import "server-only";
+import { createRemoteJWKSet, jwtVerify, type JWTPayload } from "jose";
+import { clientId, clientSecret, issuer, redirectUri } from "./oidc-config";
+
+export interface OidcDiscovery {
+  authorization_endpoint: string;
+  token_endpoint: string;
+  jwks_uri: string;
+  userinfo_endpoint?: string;
+}
+
+// Kein Caching des Discovery-Dokuments: Login ist bei ~250 Mitarbeitern
+// kein Hot Path, ein zusätzlicher HTTPS-Request pro Anmeldeversuch
+// fällt nicht ins Gewicht – vermeidet Cache-Invalidierungslogik ohne
+// echten Bedarf.
+export async function discover(): Promise<OidcDiscovery> {
+  const res = await fetch(`${issuer().replace(/\/$/, "")}/.well-known/openid-configuration`);
+  if (!res.ok) throw new Error(`oidc_discovery_failed_${res.status}`);
+  return (await res.json()) as OidcDiscovery;
+}
+
+export function buildAuthorizeUrl(
+  discovery: OidcDiscovery,
+  params: { state: string; nonce: string; codeChallenge: string }
+): string {
+  const url = new URL(discovery.authorization_endpoint);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("client_id", clientId());
+  url.searchParams.set("redirect_uri", redirectUri());
+  url.searchParams.set("scope", "openid email profile");
+  url.searchParams.set("state", params.state);
+  url.searchParams.set("nonce", params.nonce);
+  url.searchParams.set("code_challenge", params.codeChallenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  return url.toString();
+}
+
+export async function exchangeCode(
+  discovery: OidcDiscovery,
+  code: string,
+  codeVerifier: string
+): Promise<{ idToken: string; accessToken: string | null }> {
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: clientId(),
+    client_secret: clientSecret(),
+    redirect_uri: redirectUri(),
+    code,
+    code_verifier: codeVerifier,
+  });
+  const res = await fetch(discovery.token_endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body,
+  });
+  if (!res.ok) throw new Error(`oidc_token_exchange_failed_${res.status}`);
+  const data = (await res.json()) as { id_token?: string; access_token?: string };
+  if (!data.id_token) throw new Error("oidc_missing_id_token");
+  return { idToken: data.id_token, accessToken: data.access_token ?? null };
+}
+
+// Algorithmus bewusst auf RS256 festgenagelt (Authentik-Standard) statt
+// dem Token zu vertrauen, welchen Algorithmus es selbst behauptet zu
+// nutzen ("algorithm confusion"-Angriffsklasse bei JWTs).
+export async function verifyIdToken(
+  discovery: OidcDiscovery,
+  idToken: string,
+  expectedNonce: string
+): Promise<JWTPayload> {
+  const jwks = createRemoteJWKSet(new URL(discovery.jwks_uri));
+  const { payload } = await jwtVerify(idToken, jwks, {
+    issuer: issuer(),
+    audience: clientId(),
+    algorithms: ["RS256"],
+  });
+  if (payload.nonce !== expectedNonce) {
+    throw new Error("oidc_nonce_mismatch");
+  }
+  if (payload.email_verified === false) {
+    throw new Error("oidc_email_not_verified");
+  }
+  return payload;
+}
+
+/** E-Mail bevorzugt aus dem ID-Token, sonst Fallback auf den Userinfo-Endpoint. */
+export async function resolveEmail(
+  discovery: OidcDiscovery,
+  payload: JWTPayload,
+  accessToken: string | null
+): Promise<string | null> {
+  if (typeof payload.email === "string" && payload.email) return payload.email;
+  if (!accessToken || !discovery.userinfo_endpoint) return null;
+  const res = await fetch(discovery.userinfo_endpoint, {
+    headers: { Authorization: `Bearer ${accessToken}` },
+  });
+  if (!res.ok) return null;
+  const info = (await res.json()) as { email?: string };
+  return typeof info.email === "string" && info.email ? info.email : null;
+}
@@ -0,0 +1,35 @@
+import "server-only";
+
+// SSO-Konfiguration wird direkt aus Env-Vars abgeleitet – kein
+// Cloud-Konfigurationsschritt, analog zu lib/auth/webauthn-config.ts.
+// "Aktiviert" ergibt sich implizit aus dem Vorhandensein der drei
+// Pflicht-Vars (wie bei DEEPL_API_KEY), kein separates Enable-Flag.
+
+export function isConfigured(): boolean {
+  return !!(
+    process.env.OIDC_ISSUER &&
+    process.env.OIDC_CLIENT_ID &&
+    process.env.OIDC_CLIENT_SECRET
+  );
+}
+
+export function issuer(): string {
+  return process.env.OIDC_ISSUER!;
+}
+
+export function clientId(): string {
+  return process.env.OIDC_CLIENT_ID!;
+}
+
+export function clientSecret(): string {
+  return process.env.OIDC_CLIENT_SECRET!;
+}
+
+// Bewusst aus APP_URL abgeleitet statt aus Request-Headern (wie z. B.
+// proxy.ts es für den Login-Redirect tut): der Wert muss exakt mit der
+// beim Identity Provider hinterlegten Redirect-URI übereinstimmen,
+// darf sich also nicht je nach eingehendem Host-Header ändern.
+export function redirectUri(): string {
+  const appUrl = new URL(process.env.APP_URL ?? "http://localhost:3000");
+  return `${appUrl.origin}/api/auth/oidc/callback`;
+}
@@ -0,0 +1,31 @@
+import "server-only";
+import { query, queryOne } from "@/lib/db";
+
+const STATE_TTL_MS = 10 * 60 * 1000;
+
+export async function storeState(
+  state: string,
+  nonce: string,
+  codeVerifier: string
+): Promise<void> {
+  // Kein Cron nötig: abgelaufene Zeilen bei jedem neuen State gleich
+  // mit aufräumen (wie bei webauthn_challenges).
+  await query("delete from oidc_states where expires_at < now()");
+  await query(
+    "insert into oidc_states (state, nonce, code_verifier, expires_at) values ($1, $2, $3, $4)",
+    [state, nonce, codeVerifier, new Date(Date.now() + STATE_TTL_MS)]
+  );
+}
+
+/** Einmalig verwendbar: die Zeile wird beim Abruf sofort gelöscht. */
+export async function consumeState(
+  state: string
+): Promise<{ nonce: string; codeVerifier: string } | null> {
+  const row = await queryOne<{ nonce: string; code_verifier: string }>(
+    `delete from oidc_states
+     where state = $1 and expires_at > now()
+     returning nonce, code_verifier`,
+    [state]
+  );
+  return row ? { nonce: row.nonce, codeVerifier: row.code_verifier } : null;
+}
@@ -0,0 +1,35 @@
+import "server-only";
+import { randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
+
+// scrypt-Parameter fest verankert statt "der aktuelle Node-Default" zu
+// nutzen, damit ein künftiges Node-Upgrade die Hash-Stärke nicht
+// stillschweigend ändert. Speicherbedarf = 128 * N * r = 16 MiB.
+const N = 16384;
+const r = 8;
+const p = 1;
+const KEY_LEN = 64;
+const MAX_MEM = 32 * 1024 * 1024;
+
+// Selbstbeschreibendes Format "scrypt$N$r$p$salt$hash" (hex), damit die
+// Parameter später erhöht werden können, ohne bestehende Hashes zu
+// invalidieren.
+export function hashPassword(plain: string): string {
+  const salt = randomBytes(16);
+  const hash = scryptSync(plain, salt, KEY_LEN, { N, r, p, maxmem: MAX_MEM });
+  return `scrypt$${N}$${r}$${p}$${salt.toString("hex")}$${hash.toString("hex")}`;
+}
+
+export function verifyPassword(plain: string, stored: string): boolean {
+  const parts = stored.split("$");
+  if (parts.length !== 6 || parts[0] !== "scrypt") return false;
+  const [, nStr, rStr, pStr, saltHex, hashHex] = parts;
+  const salt = Buffer.from(saltHex, "hex");
+  const expected = Buffer.from(hashHex, "hex");
+  const actual = scryptSync(plain, salt, expected.length, {
+    N: Number(nStr),
+    r: Number(rStr),
+    p: Number(pStr),
+    maxmem: MAX_MEM,
+  });
+  return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
--- a/Show More
+++ b/Show More