Merge feature/v1.9.5: interner Bereich für Mobilgeräte nutzbar

feat: interner Bereich für Mobilgeräte nutzbar
AppHeader.tsx: Hamburger-Menü unterhalb "sm" mit denselben Links gestapelt (Vorschläge-Badge-Logik in gemeinsame renderLinks()-Funktion ausgelagert), Panel schließt automatisch bei Navigation. Bisherige einzeilige Navigation bleibt ab "sm" unverändert. WeekEditor.tsx: Mobile Tag-für-Tag-Ansicht mit Tab-Leiste (Mo-Fr) statt der 6-spaltigen Tabelle, die bei 375px unbenutzbar gequetscht war. Zellinhalt (Eintragsliste + "hinzufügen"-Flow) in renderCell() extrahiert und von Tabelle und Karten-Ansicht gemeinsam genutzt, damit der Bearbeitungs-Zustand nicht dupliziert werden muss. Desktop-Tabelle unverändert ab "sm". DishManager/CodeListManager/UserManager/SectionManager/PasskeyManager: Kopf- und Listenzeilen brechen jetzt bei Bedarf um (flex-wrap) statt Buttons abzuschneiden, gleiches Muster wie bereits in SuggestionReview.tsx vorhanden. Version 1.9.5. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-07-20 00:55:13 +02:00 · 2026-07-20 00:54:05 +02:00 · 2026-07-20 00:34:11 +02:00 · 2026-07-20 00:29:57 +02:00 · 2026-07-20 00:08:18 +02:00 · 2026-07-20 00:05:56 +02:00
113 changed files with 5668 additions and 2542 deletions
@@ -5,7 +5,7 @@ node_modules
 .env*
 !.env.example
 ZUGANGSDATEN.md
-supabase/local
+data/branding
 Dockerfile
 docker-compose.yml
 README.md
@@ -1,27 +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=
@@ -4,6 +4,232 @@ 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.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
@@ -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,24 +4,29 @@ 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`).
+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 Essenszeiten Brotzeit (09:00–10:00), Mittagessen, Mittagessen vegetarisch und Suppe (je 11:30–13:30); 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 |
-| Kantinen-Team (`/intern`) | 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 Tagen/Essenszeiten zuweisen (mehrere pro Zelle) und wieder entfernen; globale Allergen-/Zusatzstofflisten pflegen (ebenfalls mehrsprachig); eingereichte Rezeptvorschläge sichten, übernehmen oder ablehnen; eigenes Konto verwalten (Name, E-Mail, Passwort, Passkeys, Passwort-Anmeldung an/aus) |
+| Ö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 eigenen Konto nach dem ersten Login). Die
 Passwort-Anmeldung kann pro Konto deaktiviert werden, sobald mindestens
-ein Passkey registriert ist.
+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
@@ -34,23 +39,35 @@ mit optionaler automatischer Übersetzung über DeepL (siehe
 ```
 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)
-  api/translate/         DeepL-Anbindung (serverseitig)
+  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, …)
 components/i18n/        Sprachkontext, Sprachumschalter
 lib/i18n/               Wörterbücher (de/en/pl), Locale-Helfer
-lib/supabase/           Supabase-Clients (Browser / Server / Admin)
+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
@@ -66,25 +83,25 @@ 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
@@ -93,82 +110,55 @@ 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
 npm run build
-npm run start          # Port 3000, bindet an 0.0.0.0 (hinter Reverse-Proxy betreiben)
+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, Essenszeiten, 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,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,24 @@
+import { listCodes } from "@/lib/db/code-lists";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { toCsv } from "@/lib/csv";
+
+export async function GET() {
+  try {
+    await requireRole(["staff", "admin"]);
+    const items = await listCodes("additives");
+    const rows = [
+      ["code", "name", "name_en", "name_pl"],
+      ...items.map((i) => [i.code, i.name, i.name_en ?? "", i.name_pl ?? ""]),
+    ];
+    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,53 @@
+import { NextResponse } from "next/server";
+import { importCodes, type CodeImportRow } from "@/lib/db/code-lists";
+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 nameEnIdx = header.indexOf("name_en");
+    const namePlIdx = header.indexOf("name_pl");
+
+    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;
+      }
+      rows.push({
+        code,
+        name,
+        name_en: nameEnIdx >= 0 ? c[nameEnIdx]?.trim() || null : null,
+        name_pl: namePlIdx >= 0 ? c[namePlIdx]?.trim() || null : null,
+      });
+    });
+
+    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;
+  }
+}
@@ -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) {
-    return NextResponse.json(
-      {
-        error: /already been registered/i.test(error.message)
-          ? "Diese E-Mail-Adresse ist bereits registriert."
-          : error.message,
-      },
-      { status: 400 }
+  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: "Diese E-Mail-Adresse ist bereits registriert." },
+        { status: 400 }
+      );
+    }
+    throw err;
  }
-  return NextResponse.json({ id: data.user?.id });
 }

 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,24 @@
+import { listCodes } from "@/lib/db/code-lists";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { toCsv } from "@/lib/csv";
+
+export async function GET() {
+  try {
+    await requireRole(["staff", "admin"]);
+    const items = await listCodes("allergens");
+    const rows = [
+      ["code", "name", "name_en", "name_pl"],
+      ...items.map((i) => [i.code, i.name, i.name_en ?? "", i.name_pl ?? ""]),
+    ];
+    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,53 @@
+import { NextResponse } from "next/server";
+import { importCodes, type CodeImportRow } from "@/lib/db/code-lists";
+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 nameEnIdx = header.indexOf("name_en");
+    const namePlIdx = header.indexOf("name_pl");
+
+    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;
+      }
+      rows.push({
+        code,
+        name,
+        name_en: nameEnIdx >= 0 ? c[nameEnIdx]?.trim() || null : null,
+        name_pl: namePlIdx >= 0 ? c[namePlIdx]?.trim() || null : null,
+      });
+    });
+
+    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,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,57 @@
+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 { Dish } from "@/lib/types";
+
+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;
+      name_en: string | null;
+      name_pl: string | null;
+      price: number;
+      allergens: string[];
+      additives: string[];
+    };
+    const dish = await queryOne<Dish>(
+      `update dishes set name = $1, name_en = $2, name_pl = $3, price = $4,
+              allergens = $5, additives = $6
+       where id = $7 returning *`,
+      [body.name, body.name_en, body.name_pl, body.price, body.allergens, body.additives, id]
+    );
+    if (!dish) return NextResponse.json({ error: "not_found" }, { status: 404 });
+    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,32 @@
+import { query } from "@/lib/db";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { toCsv } from "@/lib/csv";
+import type { Dish } from "@/lib/types";
+
+export async function GET() {
+  try {
+    await requireRole(["staff", "admin"]);
+    const dishes = await query<Dish>("select * from dishes order by name");
+    const rows = [
+      ["name", "name_en", "name_pl", "price", "allergens", "additives"],
+      ...dishes.map((d) => [
+        d.name,
+        d.name_en ?? "",
+        d.name_pl ?? "",
+        String(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,110 @@
+import { NextResponse } from "next/server";
+import { withTransaction } from "@/lib/db";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+import { parseCsvWithHeader, splitCodes } from "@/lib/csv";
+
+interface ImportRow {
+  rowNum: number;
+  name: string;
+  name_en: string | null;
+  name_pl: string | null;
+  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 nameEnIdx = header.indexOf("name_en");
+    const namePlIdx = header.indexOf("name_pl");
+    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;
+      }
+      rows.push({
+        rowNum,
+        name,
+        name_en: nameEnIdx >= 0 ? c[nameEnIdx]?.trim() || null : null,
+        name_pl: namePlIdx >= 0 ? c[namePlIdx]?.trim() || null : null,
+        price,
+        allergens: allergensIdx >= 0 ? splitCodes(c[allergensIdx]) : [],
+        additives: additivesIdx >= 0 ? splitCodes(c[additivesIdx]) : [],
+      });
+    });
+
+    let created = 0;
+    let updated = 0;
+    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 name_en = $1, name_pl = $2, price = $3, allergens = $4, additives = $5
+               where id = $6`,
+              [row.name_en, row.name_pl, row.price, row.allergens, row.additives, existing.rows[0].id]
+            );
+            updated++;
+          } else {
+            await client.query(
+              `insert into dishes (name, name_en, name_pl, price, allergens, additives)
+               values ($1, $2, $3, $4, $5, $6)`,
+              [row.name, row.name_en, row.name_pl, row.price, row.allergens, row.additives]
+            );
+            created++;
+          }
+        }
+      });
+    }
+
+    return NextResponse.json({ created, updated, skipped });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,37 @@
+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 { Dish } from "@/lib/types";
+
+export async function GET() {
+  const dishes = await query<Dish>("select * from dishes order by name");
+  return NextResponse.json(dishes);
+}
+
+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;
+      name_en: string | null;
+      name_pl: string | null;
+      price: number;
+      allergens: string[];
+      additives: string[];
+    };
+    const dish = await queryOne<Dish>(
+      `insert into dishes (name, name_en, name_pl, price, allergens, additives)
+       values ($1, $2, $3, $4, $5, $6) returning *`,
+      [body.name, body.name_en, body.name_pl, body.price, body.allergens, body.additives]
+    );
+    return NextResponse.json(dish, { status: 201 });
+  } 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 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,62 @@
+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 { Section } from "@/lib/types";
+
+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" | "label_en" | "label_pl" | "time_range" | "sort">
+    >;
+
+    const fields: string[] = [];
+    const values: unknown[] = [];
+    for (const col of ["label", "label_en", "label_pl", "time_range", "sort"] as const) {
+      if (body[col] !== undefined) {
+        values.push(body[col]);
+        fields.push(`${col} = $${values.length}`);
+      }
+    }
+    if (fields.length === 0) return NextResponse.json({ error: "empty_update" }, { status: 400 });
+    values.push(key);
+
+    const section = await queryOne<Section>(
+      `update sections set ${fields.join(", ")} where key = $${values.length} returning *`,
+      values
+    );
+    if (!section) return NextResponse.json({ error: "not_found" }, { status: 404 });
+    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,39 @@
+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 { Section } from "@/lib/types";
+
+export async function GET() {
+  const sections = await query<Section>("select * from sections order by sort");
+  return NextResponse.json(sections);
+}
+
+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;
+      label_en: string | null;
+      label_pl: string | null;
+      time_range: string;
+    };
+
+    const maxRow = await queryOne<{ sort: number }>(
+      "select sort from sections order by sort desc limit 1"
+    );
+    const section = await queryOne<Section>(
+      `insert into sections (label, label_en, label_pl, time_range, sort)
+       values ($1, $2, $3, $4, $5) returning *`,
+      [body.label, body.label_en, body.label_pl, body.time_range, (maxRow?.sort ?? 0) + 1]
+    );
+    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;
+  }
+}
@@ -1,6 +1,6 @@
 import { NextResponse } from "next/server";
-import { createClient } from "@/lib/supabase/server";
-import { createAdminClient } from "@/lib/supabase/admin";
+import { query } from "@/lib/db";
+import { requireRole, UnauthorizedError, ForbiddenError } from "@/lib/auth/session";
 import { isSameOrigin } from "@/lib/origin";

 // Übersetzt einen deutschen Text nach Englisch/Polnisch via DeepL und
@@ -43,20 +43,16 @@ export async function POST(request: Request) {
    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
  }

-  const supabase = await createClient();
-  const {
-    data: { user },
-  } = await supabase.auth.getUser();
-  if (!user) return NextResponse.json({ error: "Nicht angemeldet." }, { status: 401 });
-
-  const admin = createAdminClient();
-  const { data: profile } = await admin
-    .from("profiles")
-    .select("role")
-    .eq("id", user.id)
-    .single();
-  if (!profile || !["staff", "admin"].includes(profile.role)) {
-    return NextResponse.json({ error: "Nicht berechtigt." }, { 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);
@@ -83,11 +79,14 @@ export async function POST(request: Request) {
    if (!en || !pl) throw new Error("Keine Übersetzung erhalten.");

    if (persist) {
-      const { error } = await admin
-        .from(table)
-        .update({ [`${config.textColumn}_en`]: en, [`${config.textColumn}_pl`]: pl })
-        .eq(config.idColumn, id);
-      if (error) throw new Error(error.message);
+      // table/idColumn/textColumn kommen ausschließlich aus dem oben
+      // geprüften ALLOWED_TABLES-Whitelist, nie aus Nutzereingaben –
+      // sicher für die String-Interpolation in der Query.
+      await query(
+        `update ${table} set ${config.textColumn}_en = $1, ${config.textColumn}_pl = $2
+         where ${config.idColumn} = $3`,
+        [en, pl, id]
+      );
    }

    return NextResponse.json({ configured: true, en, pl });
@@ -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,114 @@
+import { query } from "@/lib/db";
+import { loadMenuEntries } from "@/lib/db/menu-entries";
+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] = await Promise.all([
+    query<Section>("select * from sections order by sort"),
+    loadMenuEntries(monday, rangeEnd),
+  ]);
+
+  const days = Array.from(new Set(entries.map((e) => e.menu_date))).sort();
+
+  const items = days
+    .map((iso) => {
+      const dayContent = 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;
@@ -1,11 +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="grid gap-6 lg:grid-cols-2">
-      <CodeListManager table="allergens" translateEnabled={translateEnabled} />
-      <CodeListManager table="additives" translateEnabled={translateEnabled} />
+    <div className="flex flex-col gap-6">
+      <LabelingNoticeEditor />
+      <div className="grid gap-6 lg:grid-cols-2">
+        <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}
@@ -1,34 +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, password_auth_enabled")
-    .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 ?? ""}
-          initialPasswordAuthEnabled={profile.password_auth_enabled}
+          role={session.user.role}
+          initialFullName={session.user.full_name}
+          initialEmail={session.user.email}
+          initialPasswordAuthEnabled={session.user.password_auth_enabled}
        />
      </main>
    </div>
@@ -1,7 +1,7 @@
 import type { Metadata } from "next";
 import { Geist } from "next/font/google";
 import "./globals.css";
-import { createClient } from "@/lib/supabase/server";
+import { getSettings } from "@/lib/db/settings";
 import { COLOR_VARS, DEFAULT_COLORS, faviconUrl, SITE_TITLE } from "@/lib/types";
 import { getDictionary, getLocale } from "@/lib/i18n";
 import { LocaleProvider } from "@/components/i18n/LocaleProvider";
@@ -16,12 +16,7 @@ const geistSans = Geist({
 });

 export async function generateMetadata(): Promise<Metadata> {
-  const supabase = await createClient();
-  const { data: settings } = await supabase
-    .from("settings")
-    .select("favicon_path")
-    .eq("id", 1)
-    .maybeSingle();
+  const settings = await getSettings();

  return {
    title: SITE_TITLE,
@@ -30,6 +25,14 @@ export async function generateMetadata(): Promise<Metadata> {
    // 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` }],
+      },
+    },
  };
 }

@@ -38,16 +41,12 @@ export default async function RootLayout({
 }: Readonly<{
  children: React.ReactNode;
 }>) {
-  const supabase = await createClient();
-  const [{ data: settings }, locale] = await Promise.all([
-    supabase.from("settings").select("colors").eq("id", 1).maybeSingle(),
-    getLocale(),
-  ]);
+  const [settings, locale] = await Promise.all([getSettings(), getLocale()]);
  const dict = getDictionary(locale);

  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]])
@@ -1,156 +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";
-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, message: string): string {
-  if (/invalid login credentials/i.test(message))
-    return dict.login.errorInvalidCredentials;
-  if (/email not confirmed/i.test(message))
-    return dict.login.errorEmailNotConfirmed;
-  if (/cancelled|aborted|NotAllowedError/i.test(message))
-    return dict.login.errorPasskeyCancelled;
-  return formatMessage(dict.login.errorGeneric, { message });
-}
-
-export default function LoginPage() {
-  const router = useRouter();
-  const supabase = createClient();
-  const dict = useDict();
-  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(authErrorMessage(dict, error?.message ?? "Unbekannter Fehler"));
-      setBusy(false);
-      return;
-    }
-
-    const { data: profile } = await supabase
-      .from("profiles")
-      .select("role, password_auth_enabled")
-      .eq("id", data.user.id)
-      .single();
-    if (profile?.password_auth_enabled === false) {
-      await supabase.auth.signOut();
-      setError(dict.login.errorPasswordDisabled);
-      setBusy(false);
-      return;
-    }
-    router.replace(profile?.role === "admin" ? "/admin" : "/intern");
-    router.refresh();
-  }
-
-  async function signInWithPasskey() {
-    setError(null);
-    setBusy(true);
-    try {
-      const { data, error } = await supabase.auth.signInWithPasskey();
-      if (error || !data?.user) {
-        setError(
-          authErrorMessage(dict, error?.message ?? "Passkey-Anmeldung fehlgeschlagen")
-        );
-        setBusy(false);
-        return;
-      }
-      await redirectByRole(data.user.id);
-    } 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>
-
-        <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>
-  );
+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,5 +1,7 @@
 import Link from "next/link";
-import { createClient } from "@/lib/supabase/server";
+import { query } from "@/lib/db";
+import { loadMenuEntries } from "@/lib/db/menu-entries";
+import { getSettings } from "@/lib/db/settings";
 import {
  addDays,
  dishCodes,
@@ -11,7 +13,7 @@ import {
 } from "@/lib/menu";
 import { getDictionary, getLocale } from "@/lib/i18n";
 import { localized, logoUrl, SITE_TITLE } from "@/lib/types";
-import type { CodeItem, MenuEntry, Section } from "@/lib/types";
+import type { CodeItem, Section } from "@/lib/types";
 import PublicMobileMenu from "@/components/PublicMobileMenu";
 import LanguageSwitcher from "@/components/i18n/LanguageSwitcher";

@@ -31,29 +33,16 @@ export default async function Home({
    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, name_en, name_pl, price, allergens, additives)"
-        )
-        .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 [sections, entries, allergens, additives, settings] = await Promise.all([
+    query<Section>("select * from sections order by sort"),
+    loadMenuEntries(monday, friday),
+    query<CodeItem>("select * from allergens order by sort"),
+    query<CodeItem>("select * from additives order by sort"),
+    getSettings(),
+  ]);

-  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 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">
@@ -68,6 +57,25 @@ export default async function Home({
          <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)]"
@@ -92,7 +100,12 @@ export default async function Home({
      </header>

      {/* Mobil: Tag (Standard) oder Woche umschaltbar */}
-      <PublicMobileMenu monday={monday} sections={sections} entries={entries} />
+      <PublicMobileMenu
+        monday={monday}
+        sections={sections}
+        entries={entries}
+        showLabeling={labelingDetailed}
+      />

      {/* Ab "sm": klassische Wochentabelle */}
      <div className="hidden sm:block">
@@ -141,7 +154,9 @@ export default async function Home({
                            <span className="font-bold">
                              {localized(e.dish, locale)}
                            </span>
-                            {codes && <sup className="dish-codes">{codes}</sup>}
+                            {labelingDetailed && codes && (
+                              <sup className="dish-codes">{codes}</sup>
+                            )}
                            {" – "}
                            {formatPrice(e.dish.price)}
                          </div>
@@ -156,35 +171,56 @@ export default async function Home({
        </div>
      </div>

-      {/* Allergene & Zusatzstoffe: Legende zu den Kürzeln bei den Gerichten */}
-      <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">
-            {dict.publicMenu.allergens}
-          </h2>
-          <ul className="space-y-0.5">
-            {allergens.map((a) => (
-              <li key={a.code}>
-                <span className="font-semibold">{a.code}</span> –{" "}
-                {localized(a, locale)}
-              </li>
-            ))}
-          </ul>
-        </div>
-        <div>
-          <h2 className="font-bold text-[var(--c-primary)] mb-2">
-            {dict.publicMenu.additives}
-          </h2>
-          <ul className="space-y-0.5">
-            {additives.map((a) => (
-              <li key={a.code}>
-                <span className="font-semibold">{a.code}</span> –{" "}
-                {localized(a, locale)}
-              </li>
-            ))}
-          </ul>
-        </div>
-      </section>
+      {/* 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">
+              {dict.publicMenu.allergens}
+            </h2>
+            <ul className="space-y-0.5">
+              {allergens.map((a) => (
+                <li key={a.code}>
+                  <span className="font-semibold">{a.code}</span> –{" "}
+                  {localized(a, locale)}
+                </li>
+              ))}
+            </ul>
+          </div>
+          <div>
+            <h2 className="font-bold text-[var(--c-primary)] mb-2">
+              {dict.publicMenu.additives}
+            </h2>
+            <ul className="space-y-0.5">
+              {additives.map((a) => (
+                <li key={a.code}>
+                  <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>
  );
 }
@@ -1,20 +1,20 @@
 "use client";

-import { useEffect, 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 type { Dict } from "@/lib/i18n/shared";
 import PasskeyManager from "@/components/PasskeyManager";
 import { useDict } from "@/components/i18n/LocaleProvider";

-function authErrorMessage(dict: Dict, message: string): string {
-  if (/invalid login credentials/i.test(message))
-    return dict.account.wrongCurrentPassword;
-  if (/should be at least/i.test(message)) return dict.account.passwordTooShort;
-  if (/email.*already|already.*registered/i.test(message))
-    return dict.account.emailAlreadyUsed;
-  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({
@@ -28,7 +28,6 @@ export default function AccountManager({
  initialEmail: string;
  initialPasswordAuthEnabled: boolean;
 }) {
-  const supabase = useMemo(() => createClient(), []);
  const router = useRouter();
  const dict = useDict();
  const roleLabel = role === "admin" ? dict.common.roleAdmin : dict.common.roleStaff;
@@ -41,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);
@@ -63,10 +63,10 @@ export default function AccountManager({
  const [authBusy, setAuthBusy] = useState(false);

  useEffect(() => {
-    supabase.auth.passkey
-      .list()
-      .then(({ data }) => setPasskeyCount((data ?? []).length));
-  }, [supabase]);
+    fetch("/api/auth/passkeys")
+      .then((res) => (res.ok ? res.json() : []))
+      .then((data) => setPasskeyCount(data.length));
+  }, []);

  async function saveName(e: React.FormEvent) {
    e.preventDefault();
@@ -78,13 +78,19 @@ export default function AccountManager({
      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(formatMessage(dict.account.saveError, { message: error.message }));
-    else {
+    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();
    }
@@ -98,15 +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) {
+    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: authErrorMessage(dict, error.message),
+          message: errorMessage(dict, data.error, data.error ?? String(res.status)),
        })
      );
    } else {
-      setEmailInfo(dict.account.emailSent);
+      setEmailInfo(dict.account.emailChanged);
+      setEmailPassword("");
+      router.refresh();
    }
    setEmailBusy(false);
  }
@@ -125,22 +138,16 @@ export default function AccountManager({
    }
    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(authErrorMessage(dict, verifyError.message));
-      setPwBusy(false);
-      return;
-    }
-
-    const { error } = await supabase.auth.updateUser({ password: newPassword });
-    if (error) {
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
      setPwError(
        formatMessage(dict.account.changeError, {
-          message: authErrorMessage(dict, error.message),
+          message: errorMessage(dict, data.error, data.error ?? String(res.status)),
        })
      );
    } else {
@@ -163,12 +170,18 @@ export default function AccountManager({
    if (!next && !window.confirm(dict.account.confirmDisablePasswordAuth)) return;

    setAuthBusy(true);
-    const { error } = await supabase
-      .from("profiles")
-      .update({ password_auth_enabled: next })
-      .eq("id", (await supabase.auth.getUser()).data.user?.id ?? "");
-    if (error) {
-      setAuthError(formatMessage(dict.account.saveError, { message: error.message }));
+    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(
@@ -232,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}
@@ -3,14 +3,22 @@
 // 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";

+interface NavLink {
+  href: string;
+  label: string;
+}
+
 export default function AppHeader({
  role,
  displayName,
@@ -20,15 +28,29 @@ export default function AppHeader({
 }) {
  const pathname = usePathname();
  const dict = useDict();
+  const [suggestionCount, setSuggestionCount] = useState(0);
+  const [mobileOpen, setMobileOpen] = useState(false);

-  const menuLinks = [
+  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 = [
+  const adminLinks: NavLink[] = [
    { href: "/admin", label: dict.header.users },
    { href: "/admin/design", label: dict.header.design },
  ];
@@ -38,9 +60,105 @@ export default function AppHeader({
      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">
+      {/* 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
@@ -50,11 +168,7 @@ export default function AppHeader({
          <span className="mr-1 text-xs uppercase tracking-wider text-white/50">
            {dict.header.menuGroup}
          </span>
-          {menuLinks.map((l) => (
-            <Link key={l.href} href={l.href} className={linkClass(l.href)}>
-              {l.label}
-            </Link>
-          ))}
+          {renderLinks(menuLinks)}
        </nav>

        {role === "admin" && (
@@ -65,11 +179,7 @@ export default function AppHeader({
            <span className="mr-1 text-xs uppercase tracking-wider text-white/50">
              {dict.header.adminGroup}
            </span>
-            {adminLinks.map((l) => (
-              <Link key={l.href} href={l.href} className={linkClass(l.href)}>
-                {l.label}
-              </Link>
-            ))}
+            {renderLinks(adminLinks)}
          </nav>
        )}

@@ -3,8 +3,7 @@
 // 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";
@@ -17,7 +16,6 @@ export default function CodeListManager({
  table: "allergens" | "additives";
  translateEnabled: boolean;
 }) {
-  const supabase = useMemo(() => createClient(), []);
  const dict = useDict();
  const locale = useLocale();
  const title =
@@ -36,15 +34,17 @@ export default function CodeListManager({
    namePl: 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(formatMessage(dict.codeList.loadError, { message: error.message }));
-    else setItems(data as CodeItem[]);
-  }, [supabase, table, dict]);
+    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();
@@ -64,23 +64,23 @@ export default function CodeListManager({
      name_pl: editing.namePl.trim() || null,
    };

-    let dbError;
-    if (editing.original) {
-      ({ error: dbError } = await supabase
-        .from(table)
-        .update(payload)
-        .eq("code", editing.original));
-    } else {
-      const maxSort = items.reduce((m, i) => Math.max(m, i.sort), 0);
-      ({ error: dbError } = await supabase
-        .from(table)
-        .insert({ ...payload, 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)
+        data.error === "duplicate_code"
          ? formatMessage(dict.codeList.duplicateCode, { code })
-          : formatMessage(dict.codeList.saveError, { message: dbError.message })
+          : formatMessage(dict.codeList.saveError, { message: data.error ?? String(res.status) })
      );
      return;
    }
@@ -95,9 +95,9 @@ export default function CodeListManager({
      )
    )
      return;
-    const { error } = await supabase.from(table).delete().eq("code", item.code);
-    if (error)
-      setError(formatMessage(dict.codeList.deleteError, { message: 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();
  }

@@ -127,12 +127,77 @@ export default function CodeListManager({
    }
  }

+  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"
@@ -150,6 +215,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">
@@ -225,7 +291,7 @@ 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> –{" "}
              {localized(item, locale)}
@@ -1,21 +1,14 @@
 "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 { formatMessage } from "@/lib/i18n/shared";
 import { DEFAULT_COLORS, faviconUrl, logoUrl } from "@/lib/types";
 import { useDict } from "@/components/i18n/LocaleProvider";

 type AssetKind = "logo" | "favicon";

-const ASSET_COLUMN: Record<AssetKind, "logo_path" | "favicon_path"> = {
-  logo: "logo_path",
-  favicon: "favicon_path",
-};
-
 export default function DesignEditor() {
-  const supabase = useMemo(() => createClient(), []);
  const router = useRouter();
  const dict = useDict();
  const colorLabels: Record<string, string> = {
@@ -36,19 +29,16 @@ export default function DesignEditor() {
  const [busy, setBusy] = useState(false);

  const load = useCallback(async () => {
-    const { data, error } = await supabase
-      .from("settings")
-      .select("colors, logo_path, favicon_path")
-      .eq("id", 1)
-      .maybeSingle();
-    if (error) {
-      setError(formatMessage(dict.designEditor.loadError, { message: 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);
    setFaviconPath(data?.favicon_path ?? null);
-  }, [supabase, dict]);
+  }, [dict]);

  useEffect(() => {
    load();
@@ -58,12 +48,13 @@ export default function DesignEditor() {
    setBusy(true);
    setError(null);
    setInfo(null);
-    const { error } = await supabase
-      .from("settings")
-      .update({ colors })
-      .eq("id", 1);
-    if (error)
-      setError(formatMessage(dict.designEditor.saveError, { message: 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(dict.designEditor.colorsSaved);
      router.refresh();
@@ -87,28 +78,21 @@ export default function DesignEditor() {
    setError(null);
    setInfo(null);

-    const oldPath = kind === "logo" ? logoPath : faviconPath;
-    const ext = file.name.split(".").pop()?.toLowerCase() ?? "png";
-    const path = `${kind}-${Date.now()}.${ext}`;
-    const { error: uploadError } = await supabase.storage
-      .from("branding")
-      .upload(path, file, { contentType: file.type });
-    if (uploadError) {
-      setError(formatMessage(dict.designEditor.uploadError, { message: 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 { error: settingsError } = await supabase
-      .from("settings")
-      .update({ [ASSET_COLUMN[kind]]: path })
-      .eq("id", 1);
-    if (settingsError) {
-      setError(formatMessage(dict.designEditor.saveError, { message: settingsError.message }));
-      setBusy(false);
-      return;
-    }
-    if (oldPath) await supabase.storage.from("branding").remove([oldPath]);
+    const { path } = await res.json();

    if (kind === "logo") setLogoPath(path);
    else setFaviconPath(path);
@@ -130,14 +114,14 @@ export default function DesignEditor() {
      return;
    setBusy(true);
    setError(null);
-    const { error } = await supabase
-      .from("settings")
-      .update({ [ASSET_COLUMN[kind]]: null })
-      .eq("id", 1);
-    if (error) {
-      setError(formatMessage(dict.designEditor.saveError, { message: 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([path]);
      if (kind === "logo") setLogoPath(null);
      else setFaviconPath(null);
      setInfo(kind === "logo" ? dict.designEditor.logoRemoved : dict.designEditor.faviconRemoved);
@@ -180,7 +164,7 @@ export default function DesignEditor() {
            {dict.designEditor.logoUpload}
            <input
              type="file"
-              accept="image/*"
+              accept="image/png,image/jpeg,image/webp,image/gif,image/x-icon"
              className="hidden"
              onChange={(e) => uploadAsset("logo", e)}
              disabled={busy}
@@ -217,7 +201,7 @@ export default function DesignEditor() {
            {dict.designEditor.faviconUpload}
            <input
              type="file"
-              accept="image/*"
+              accept="image/png,image/jpeg,image/webp,image/gif,image/x-icon"
              className="hidden"
              onChange={(e) => uploadAsset("favicon", e)}
              disabled={busy}
@@ -1,7 +1,6 @@
 "use client";

 import { useCallback, useEffect, useMemo, useState } from "react";
-import { createClient } from "@/lib/supabase/client";
 import { dishCodes, formatPrice } from "@/lib/menu";
 import { formatMessage } from "@/lib/i18n/shared";
 import { localized } from "@/lib/types";
@@ -34,7 +33,6 @@ export default function DishManager({
 }: {
  translateEnabled: boolean;
 }) {
-  const supabase = useMemo(() => createClient(), []);
  const dict = useDict();
  const locale = useLocale();
  const [dishes, setDishes] = useState<Dish[]>([]);
@@ -42,10 +40,13 @@ export default function DishManager({
  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"
  );
@@ -57,21 +58,25 @@ export default function DishManager({
  }, [dishes, search]);

  const load = useCallback(async () => {
-    const [dishesRes, allergensRes, additivesRes] = await Promise.all([
-      supabase.from("dishes").select("*").order("name"),
-      supabase.from("allergens").select("*").order("sort"),
-      supabase.from("additives").select("*").order("sort"),
+    const [dishesRes, allergensRes, additivesRes, settingsRes] = await Promise.all([
+      fetch("/api/dishes"),
+      fetch("/api/allergens"),
+      fetch("/api/additives"),
+      fetch("/api/settings"),
    ]);
-    const problem = dishesRes.error ?? allergensRes.error ?? additivesRes.error;
-    if (problem)
-      setError(formatMessage(dict.dishManager.loadError, { message: problem.message }));
-    else {
-      setDishes(dishesRes.data as Dish[]);
-      setAllergens(allergensRes.data as CodeItem[]);
-      setAdditives(additivesRes.data as CodeItem[]);
+    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]);
+  }, [dict]);

  useEffect(() => {
    load();
@@ -94,11 +99,19 @@ export default function DishManager({
      allergens: form.allergens,
      additives: form.additives,
    };
-    const { error } = form.id
-      ? await supabase.from("dishes").update(payload).eq("id", form.id)
-      : await supabase.from("dishes").insert(payload);
-    if (error) {
-      setError(formatMessage(dict.dishManager.saveError, { message: error.message }));
+    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);
@@ -112,9 +125,9 @@ export default function DishManager({
      )
    )
      return;
-    const { error } = await supabase.from("dishes").delete().eq("id", dish.id);
-    if (error)
-      setError(formatMessage(dict.dishManager.deleteError, { message: 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);
@@ -156,12 +169,13 @@ export default function DishManager({
      return;
    setBulkBusy(true);
    setError(null);
-    const { error } = await supabase
-      .from("dishes")
-      .delete()
-      .in("id", Array.from(selected));
-    if (error)
-      setError(formatMessage(dict.dishManager.deleteError, { message: 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();
@@ -213,15 +227,80 @@ export default function DishManager({
    }
  }

+  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">
          {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"
@@ -239,6 +318,7 @@ 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-4">
@@ -316,18 +396,24 @@ export default function DishManager({
            </div>
          )}

-          <ChipPicker
-            label={dict.codeList.allergensTitle}
-            items={allergens}
-            selected={form.allergens}
-            onToggle={toggleAllergen}
-          />
-          <ChipPicker
-            label={dict.codeList.additivesTitle}
-            items={additives}
-            selected={form.additives}
-            onToggle={toggleAdditive}
-          />
+          {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">
              {dict.common.save}
@@ -358,7 +444,7 @@ export default function DishManager({
            />
          )}
          {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"
@@ -388,7 +474,7 @@ export default function DishManager({
            {visible.map((dish) => {
              const codes = dishCodes(dish);
              return (
-                <li key={dish.id} className="flex items-center gap-3 px-4 py-2">
+                <li key={dish.id} className="flex flex-wrap items-center gap-3 px-4 py-2">
                  <input
                    type="checkbox"
                    checked={selected.has(dish.id)}
@@ -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,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,19 +1,18 @@
 "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);
@@ -21,11 +20,13 @@ export default function PasskeyManager() {
  const [busy, setBusy] = useState(false);

  const load = useCallback(async () => {
-    const { data, error } = await supabase.auth.passkey.list();
-    if (error)
-      setError(formatMessage(dict.passkeys.loadError, { message: error.message }));
-    else setPasskeys((data ?? []) as PasskeyItem[]);
-  }, [supabase, dict]);
+    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();
@@ -36,13 +37,22 @@ export default function PasskeyManager() {
    setInfo(null);
    setBusy(true);
    try {
-      const { error } = await supabase.auth.registerPasskey();
-      if (error) {
-        setError(formatMessage(dict.passkeys.registerError, { message: error.message }));
-      } else {
-        setInfo(dict.passkeys.registered);
-        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))
@@ -57,9 +67,9 @@ export default function PasskeyManager() {

  async function remove(pk: PasskeyItem) {
    if (!window.confirm(dict.passkeys.confirmDelete)) return;
-    const { error } = await supabase.auth.passkey.delete({ passkeyId: pk.id });
-    if (error)
-      setError(formatMessage(dict.passkeys.deleteError, { message: error.message }));
+    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();
  }

@@ -86,11 +96,9 @@ export default function PasskeyManager() {

      <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">
                {formatMessage(dict.passkeys.createdOn, {
                  date: new Date(pk.created_at).toLocaleDateString(dict.dateLocale),
@@ -27,10 +27,12 @@ export default function PublicMobileMenu({
  monday,
  sections,
  entries,
+  showLabeling,
 }: {
  monday: string;
  sections: Section[];
  entries: MenuEntry[];
+  showLabeling: boolean;
 }) {
  const router = useRouter();
  const dict = useDict();
@@ -86,7 +88,9 @@ export default function PublicMobileMenu({
                          <span className="font-semibold">
                            {localized(e.dish, locale)}
                          </span>
-                          {codes && <sup className="dish-codes">{codes}</sup>}{" "}
+                          {showLabeling && codes && (
+                            <sup className="dish-codes">{codes}</sup>
+                          )}{" "}
                          – {formatPrice(e.dish.price)}
                        </p>
                      );
@@ -3,8 +3,7 @@
 // Verwaltung der Essenszeiten (Brotzeit, Mittagessen, …):
 // anlegen, umbenennen, Uhrzeit ändern, löschen, Reihenfolge anpassen.

-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 { Section } from "@/lib/types";
@@ -34,7 +33,6 @@ function splitTimeRange(range: string): { from: string; to: string } {
 }

 export default function SectionManager() {
-  const supabase = useMemo(() => createClient(), []);
  const dict = useDict();
  const locale = useLocale();
  const [sections, setSections] = useState<Section[]>([]);
@@ -44,12 +42,12 @@ export default function SectionManager() {
  const [busy, setBusy] = useState(false);

  const load = useCallback(async () => {
-    const { data, error } = await supabase.from("sections").select("*").order("sort");
-    if (error)
-      setError(formatMessage(dict.sectionManager.loadError, { message: error.message }));
-    else setSections(data as Section[]);
+    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);
-  }, [supabase, dict]);
+  }, [dict]);

  useEffect(() => {
    load();
@@ -68,27 +66,19 @@ export default function SectionManager() {
      time_range: `${form.timeFrom} - ${form.timeTo}`,
    };

-    let dbError;
-    if (form.key) {
-      ({ error: dbError } = await supabase
-        .from("sections")
-        .update(payload)
-        .eq("key", form.key));
-    } else {
-      // Frisch aus der DB lesen statt den lokalen State zu nutzen, damit
-      // ein veralteter Snapshot nicht zu doppelten sort-Werten führt.
-      const { data: maxRow } = await supabase
-        .from("sections")
-        .select("sort")
-        .order("sort", { ascending: false })
-        .limit(1)
-        .maybeSingle();
-      ({ error: dbError } = await supabase
-        .from("sections")
-        .insert({ ...payload, sort: (maxRow?.sort ?? 0) + 1 }));
-    }
-    if (dbError) {
-      setError(formatMessage(dict.sectionManager.saveError, { message: dbError.message }));
+    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);
@@ -102,9 +92,9 @@ export default function SectionManager() {
      )
    )
      return;
-    const { error } = await supabase.from("sections").delete().eq("key", section.key);
-    if (error)
-      setError(formatMessage(dict.sectionManager.deleteError, { message: error.message }));
+    const res = await fetch(`/api/sections/${section.key}`, { method: "DELETE" });
+    if (!res.ok)
+      setError(formatMessage(dict.sectionManager.deleteError, { message: String(res.status) }));
    await load();
  }

@@ -115,19 +105,26 @@ export default function SectionManager() {
    setBusy(true);
    setError(null);
    const [r1, r2] = await Promise.all([
-      supabase.from("sections").update({ sort: neighbor.sort }).eq("key", section.key),
-      supabase.from("sections").update({ sort: section.sort }).eq("key", neighbor.key),
+      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 }),
+      }),
    ]);
-    const dbError = r1.error ?? r2.error;
-    if (dbError)
-      setError(formatMessage(dict.sectionManager.saveError, { message: dbError.message }));
+    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 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">
          {dict.sectionManager.title}
        </h1>
@@ -235,7 +232,7 @@ export default function SectionManager() {
      ) : (
        <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 items-center gap-3 px-4 py-2">
+            <li key={section.key} className="flex flex-wrap items-center gap-3 px-4 py-2">
              <div className="flex flex-col">
                <button
                  type="button"
@@ -2,13 +2,11 @@

 import { useState } from "react";
 import Link from "next/link";
-import { createClient } from "@/lib/supabase/client";
 import { formatMessage } from "@/lib/i18n/shared";
 import { useDict } from "@/components/i18n/LocaleProvider";
 import LanguageSwitcher from "@/components/i18n/LanguageSwitcher";

 export default function SuggestionForm() {
-  const supabase = createClient();
  const dict = useDict();
  const [name, setName] = useState("");
  const [description, setDescription] = useState("");
@@ -34,23 +32,20 @@ export default function SuggestionForm() {
    }
    setBusy(true);

-    const { data: existing } = await supabase
-      .from("dishes")
-      .select("id")
-      .ilike("name", trimmedName)
-      .limit(1);
-    if (existing && existing.length > 0) {
-      setError(dict.suggestions.duplicate);
-      setBusy(false);
-      return;
-    }
-
-    const { error: insertError } = await supabase.from("dish_suggestions").insert({
-      name: trimmedName,
-      description: description.trim() || null,
+    const res = await fetch("/api/dish-suggestions", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: trimmedName, description: description.trim() || null }),
    });
-    if (insertError) {
-      setError(formatMessage(dict.suggestions.genericError, { message: insertError.message }));
+    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;
    }
@@ -1,13 +1,11 @@
 "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 { useDict } from "@/components/i18n/LocaleProvider";
 import type { DishSuggestion } from "@/lib/types";

 export default function SuggestionReview() {
-  const supabase = useMemo(() => createClient(), []);
  const dict = useDict();
  const [items, setItems] = useState<DishSuggestion[]>([]);
  const [loading, setLoading] = useState(true);
@@ -16,15 +14,12 @@ export default function SuggestionReview() {
  const [busyId, setBusyId] = useState<string | null>(null);

  const load = useCallback(async () => {
-    const { data, error } = await supabase
-      .from("dish_suggestions")
-      .select("*")
-      .order("created_at", { ascending: false });
-    if (error)
-      setError(formatMessage(dict.suggestions.loadError, { message: error.message }));
-    else setItems(data as DishSuggestion[]);
+    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);
-  }, [supabase, dict]);
+  }, [dict]);

  useEffect(() => {
    load();
@@ -34,25 +29,9 @@ export default function SuggestionReview() {
    setBusyId(item.id);
    setError(null);
    setInfo(null);
-    const { error: insertError } = await supabase.from("dishes").insert({
-      name: item.name,
-      price: 0,
-    });
-    if (insertError) {
-      setError(
-        formatMessage(dict.suggestions.actionError, { message: insertError.message })
-      );
-      setBusyId(null);
-      return;
-    }
-    const { error: deleteError } = await supabase
-      .from("dish_suggestions")
-      .delete()
-      .eq("id", item.id);
-    if (deleteError) {
-      setError(
-        formatMessage(dict.suggestions.actionError, { message: deleteError.message })
-      );
+    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;
    }
@@ -67,9 +46,9 @@ export default function SuggestionReview() {
    setBusyId(item.id);
    setError(null);
    setInfo(null);
-    const { error } = await supabase.from("dish_suggestions").delete().eq("id", item.id);
-    if (error) {
-      setError(formatMessage(dict.suggestions.actionError, { message: error.message }));
+    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);
    }
@@ -1,7 +1,6 @@
 "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";
@@ -24,30 +23,23 @@ const EMPTY_FORM: UserForm = {
  passwordRepeat: "",
 };

-export default function UserManager() {
-  const supabase = useMemo(() => createClient(), []);
+export default function UserManager({ meId }: { meId: string }) {
  const dict = useDict();
  const roleLabels: Record<Role, string> = {
    admin: dict.common.roleAdmin,
    staff: dict.common.roleStaff,
  };
  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(formatMessage(dict.userManager.loadError, { message: profileError.message }));
-    else setProfiles(profileData as Profile[]);
-    setMe(userData.user?.id ?? null);
-  }, [supabase, dict]);
+    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();
@@ -114,7 +106,7 @@ 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">
          {dict.userManager.title}
        </h1>
@@ -229,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} – {roleLabels[p.role]}
              </span>
-              {p.id === me && <span className="text-gray-400"> {dict.common.you}</span>}
+              {p.id === meId && <span className="text-gray-400"> {dict.common.you}</span>}
            </span>
            <button
              type="button"
@@ -253,7 +245,7 @@ export default function UserManager() {
            >
              {dict.common.edit}
            </button>
-            {p.id !== me && (
+            {p.id !== meId && (
              <button
                type="button"
                className="btn btn-del"
@@ -1,8 +1,7 @@
 "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,
  dishCodes,
@@ -11,6 +10,7 @@ import {
  formatPrice,
  mondayOf,
  todayISO,
+  weekdayIndex,
 } from "@/lib/menu";
 import { formatMessage } from "@/lib/i18n/shared";
 import { localized } from "@/lib/types";
@@ -18,14 +18,16 @@ import type { Dish, MenuEntry, Section } from "@/lib/types";
 import { useDict, useLocale } from "@/components/i18n/LocaleProvider";

 export default function WeekEditor({ monday }: { monday: string }) {
-  const supabase = useMemo(() => createClient(), []);
  const dict = useDict();
  const locale = useLocale();
  const friday = addDays(monday, 4);
  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[]>([]);
@@ -37,32 +39,38 @@ 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);
+
+  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, name_en, name_pl, price, allergens, additives)"
-        )
-        .gte("menu_date", monday)
-        .lte("menu_date", friday)
-        .order("position")
-        .order("created_at"),
+      fetch("/api/sections"),
+      fetch("/api/dishes"),
+      fetch(`/api/menu-entries?from=${monday}&to=${friday}`),
    ]);
-    const problem = se.error ?? di.error ?? en.error;
-    if (problem) {
-      setError(formatMessage(dict.weekEditor.loadError, { message: problem.message }));
+    if (!se.ok || !di.ok || !en.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());
    }
    setLoading(false);
-  }, [supabase, monday, friday, dict]);
+  }, [monday, friday, dict]);

  useEffect(() => {
    setLoading(true);
@@ -71,31 +79,151 @@ export default function WeekEditor({ monday }: { monday: string }) {

  async function addEntry() {
    if (!adding || !selectedDish) return;
-    const { error } = await supabase.from("menu_entries").insert({
-      menu_date: adding.iso,
-      section_key: adding.section,
-      dish_id: selectedDish,
+    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)
+        data.error === "duplicate_entry"
          ? dict.weekEditor.duplicateEntry
-          : formatMessage(dict.weekEditor.saveError, { message: error.message })
+          : 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(formatMessage(dict.weekEditor.deleteError, { message: 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 [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;
+
+  // 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 (
+            <div key={e.id} className="dish">
+              <span className="font-bold">{localized(e.dish, locale)}</span>
+              {codes && <sup className="dish-codes">{codes}</sup>}
+              {" – "}
+              {formatPrice(e.dish.price)}
+              <div className="mt-1">
+                <button
+                  type="button"
+                  className="btn btn-del"
+                  onClick={() => removeEntry(e.id)}
+                >
+                  {dict.common.delete}
+                </button>
+              </div>
+            </div>
+          );
+        })}
+        {isAdding ? (
+          <div className="mt-2 space-y-1 text-left">
+            {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}
+                >
+                  ×
+                </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>
+                  ))}
+                  {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"
+                className="btn btn-add"
+                onClick={addEntry}
+                disabled={!selectedDish}
+              >
+                {dict.common.add}
+              </button>
+              <button type="button" className="btn btn-neutral" onClick={cancelAdding}>
+                {dict.common.cancel}
+              </button>
+            </div>
+          </div>
+        ) : (
+          <button
+            type="button"
+            className="btn btn-add mt-1"
+            onClick={() => startAdding(iso, sectionKey)}
+          >
+            {dict.weekEditor.addMeal}
+          </button>
+        )}
+      </>
+    );
+  }
+
+  const selectedDay = days[selectedDayIdx];

  return (
    <div>
@@ -125,107 +253,76 @@ export default function WeekEditor({ monday }: { monday: string }) {
      {loading ? (
        <p className="text-gray-500">{dict.weekEditor.loading}</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, dict.dateLocale)}
-                </th>
+        <>
+          {/* 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>
              ))}
-            </tr>
-          </thead>
-          <tbody>
-            {sections.map((s) => (
-              <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 isAdding =
-                    adding?.iso === d.iso && adding?.section === s.key;
-                  return (
-                    <td key={d.iso} className="cell">
-                      {entriesFor(entries, d.iso, s.key).map((e) => {
-                        const codes = dishCodes(e.dish);
-                        return (
-                          <div key={e.id} className="dish">
-                            <span className="font-bold">
-                              {localized(e.dish, locale)}
-                            </span>
-                            {codes && <sup className="dish-codes">{codes}</sup>}
-                            {" – "}
-                            {formatPrice(e.dish.price)}
-                            <div className="mt-1">
-                              <button
-                                type="button"
-                                className="btn btn-del"
-                                onClick={() => removeEntry(e.id)}
-                              >
-                                {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)}
-                          >
-                            <option value="">{dict.weekEditor.selectDish}</option>
-                            {dishes.map((dish) => (
-                              <option key={dish.id} value={dish.id}>
-                                {localized(dish, locale)} ({formatPrice(dish.price)})
-                              </option>
-                            ))}
-                          </select>
-                          <div className="flex gap-1 justify-center">
-                            <button
-                              type="button"
-                              className="btn btn-add"
-                              onClick={addEntry}
-                              disabled={!selectedDish}
-                            >
-                              {dict.common.add}
-                            </button>
-                            <button
-                              type="button"
-                              className="btn btn-neutral"
-                              onClick={() => {
-                                setAdding(null);
-                                setSelectedDish("");
-                              }}
-                            >
-                              {dict.common.cancel}
-                            </button>
-                          </div>
-                        </div>
-                      ) : (
-                        <button
-                          type="button"
-                          className="btn btn-add mt-1"
-                          onClick={() => {
-                            setAdding({ iso: d.iso, section: s.key });
-                            setSelectedDish("");
-                          }}
-                        >
-                          {dict.weekEditor.addMeal}
-                        </button>
-                      )}
-                    </td>
-                  );
-                })}
-              </tr>
-            ))}
-          </tbody>
-        </table>
+            </div>
+            <h2 className="font-bold text-[var(--c-primary)] mb-2">
+              {selectedDay.weekday} · {formatDateLong(selectedDay.iso, dict.dateLocale)}
+            </h2>
+            <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)}
+                    </th>
+                  ))}
+                </tr>
+              </thead>
+              <tbody>
+                {sections.map((s) => (
+                  <tr key={s.key}>
+                    <th className="section-head">
+                      <div>{localized(s, locale)}</div>
+                      <div className="time">{s.time_range}</div>
+                    </th>
+                    {days.map((d) => (
+                      <td key={d.iso} className="cell">
+                        {renderCell(d.iso, s.key)}
+                      </td>
+                    ))}
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        </>
      )}
      <p className="mt-4 text-sm text-gray-500">
        {hintBefore}
@@ -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,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,130 @@
+-- =============================================================
+-- 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, label_en, label_pl, time_range, sort) values
+  ('brotzeit',        'Brotzeit',                'Breakfast',              'Śniadanie',                  '09:00 - 10:00', 1),
+  ('mittagessen',     'Mittagessen',             'Lunch',                  'Obiad',                       '11:30 - 13:30', 2),
+  ('mittagessen_veg', 'Mittagessen vegetarisch', 'Lunch (vegetarian)',     'Obiad (wegetariański)',       '11:30 - 13:30', 3),
+  ('suppe',           'Suppe',                   'Soup',                   'Zupa',                        '11:30 - 13:30', 4);
+
+-- ---------- Allergene (EU-Kennzeichnung, Buchstaben) ----------
+insert into allergens (code, name, name_en, name_pl, sort) values
+  ('A', 'Glutenhaltiges Getreide',        'Cereals containing gluten',        'Zboża zawierające gluten',      1),
+  ('B', 'Krebstiere',                     'Crustaceans',                      'Skorupiaki',                     2),
+  ('C', 'Eier',                           'Eggs',                             'Jaja',                           3),
+  ('D', 'Fisch',                          'Fish',                             'Ryby',                           4),
+  ('E', 'Erdnüsse',                       'Peanuts',                          'Orzeszki ziemne',                5),
+  ('F', 'Sojabohnen',                     'Soybeans',                         'Soja',                           6),
+  ('G', 'Milch (einschließlich Laktose)', 'Milk (including lactose)',         'Mleko (w tym laktoza)',          7),
+  ('H', 'Schalenfrüchte (Nüsse)',         'Tree nuts',                        'Orzechy',                        8),
+  ('I', 'Sellerie',                       'Celery',                           'Seler',                          9),
+  ('J', 'Senf',                           'Mustard',                          'Gorczyca',                      10),
+  ('K', 'Sesamsamen',                     'Sesame seeds',                     'Nasiona sezamu',                11),
+  ('L', 'Schwefeldioxid und Sulfite',     'Sulphur dioxide and sulphites',    'Dwutlenek siarki i siarczyny',  12),
+  ('M', 'Lupinen',                        'Lupin',                            'Łubin',                         13),
+  ('N', 'Weichtiere',                     'Molluscs',                         'Mięczaki',                      14);
+
+-- ---------- Zusatzstoffe (Ziffern) ----------
+insert into additives (code, name, name_en, name_pl, sort) values
+  ('1',  'mit Farbstoff',                    'with colouring',                       'z barwnikiem',                     1),
+  ('2',  'mit Konservierungsstoff',          'with preservative',                    'z konserwantem',                   2),
+  ('3',  'mit Antioxidationsmittel',         'with antioxidant',                     'z przeciwutleniaczem',             3),
+  ('4',  'mit Geschmacksverstärker',         'with flavour enhancer',                'ze wzmacniaczem smaku',            4),
+  ('5',  'geschwefelt',                      'sulphured',                            'siarkowany',                       5),
+  ('6',  'geschwärzt',                       'blackened',                            'barwiony na czarno',               6),
+  ('7',  'gewachst',                         'waxed',                                'woskowany',                        7),
+  ('8',  'mit Phosphat',                     'with phosphate',                       'z fosforanem',                     8),
+  ('9',  'mit Süßungsmittel(n)',             'with sweetener(s)',                    'ze słodzikiem/słodzikami',         9),
+  ('10', 'enthält eine Phenylalaninquelle',  'contains a source of phenylalanine',   'zawiera źródło fenyloalaniny',    10),
+  ('11', 'koffeinhaltig',                    'caffeinated',                          'zawiera kofeinę',                 11);
+
+-- ---------- 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,45 +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
-      # (Kürzel-Erklärungen, Bereichen) nach Englisch/Polnisch. Ohne Key
+      # (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) ----------
@@ -70,18 +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);
+}
@@ -0,0 +1,131 @@
+import "server-only";
+import { createHash, randomBytes } from "node:crypto";
+import { cookies } from "next/headers";
+import { query, queryOne } from "@/lib/db";
+import type { Role } from "@/lib/types";
+
+export const SESSION_COOKIE = "session";
+const SESSION_LIFETIME_MS = 30 * 24 * 60 * 60 * 1000; // 30 Tage
+const REFRESH_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1000; // unter 7 Tage Restlaufzeit verlängern
+
+export interface SessionUser {
+  id: string;
+  email: string;
+  full_name: string;
+  role: Role;
+  password_auth_enabled: boolean;
+}
+
+export interface Session {
+  user: SessionUser;
+  expiresAt: Date;
+}
+
+function hashToken(token: string): string {
+  return createHash("sha256").update(token).digest("hex");
+}
+
+function isSecureCookie(): boolean {
+  return (process.env.APP_URL ?? "").startsWith("https://");
+}
+
+/** Nur lesend – sicher in Server Components, Route Handlern und Server Actions. */
+export async function getSession(): Promise<Session | null> {
+  const token = (await cookies()).get(SESSION_COOKIE)?.value;
+  if (!token) return null;
+
+  const row = await queryOne<{
+    expires_at: Date;
+    id: string;
+    email: string;
+    full_name: string;
+    role: Role;
+    password_auth_enabled: boolean;
+  }>(
+    `select s.expires_at, u.id, u.email, u.full_name, u.role, u.password_auth_enabled
+     from sessions s join users u on u.id = s.user_id
+     where s.token_hash = $1 and s.expires_at > now()`,
+    [hashToken(token)]
+  );
+  if (!row) return null;
+
+  return {
+    expiresAt: row.expires_at,
+    user: {
+      id: row.id,
+      email: row.email,
+      full_name: row.full_name,
+      role: row.role,
+      password_auth_enabled: row.password_auth_enabled,
+    },
+  };
+}
+
+export class UnauthorizedError extends Error {}
+export class ForbiddenError extends Error {}
+
+export async function requireSession(): Promise<Session> {
+  const session = await getSession();
+  if (!session) throw new UnauthorizedError();
+  return session;
+}
+
+export async function requireRole(roles: Role[]): Promise<Session> {
+  const session = await requireSession();
+  if (!roles.includes(session.user.role)) throw new ForbiddenError();
+  return session;
+}
+
+/** Legt eine neue Sitzung an und setzt das Session-Cookie. Nur in Route
+ *  Handlern/Server Actions aufrufbar (dort ist cookies().set() erlaubt). */
+export async function createSession(userId: string): Promise<void> {
+  const token = randomBytes(32).toString("base64url");
+  const expiresAt = new Date(Date.now() + SESSION_LIFETIME_MS);
+
+  await query(
+    "insert into sessions (token_hash, user_id, expires_at) values ($1, $2, $3)",
+    [hashToken(token), userId, expiresAt]
+  );
+
+  (await cookies()).set(SESSION_COOKIE, token, {
+    httpOnly: true,
+    secure: isSecureCookie(),
+    sameSite: "lax",
+    path: "/",
+    expires: expiresAt,
+  });
+}
+
+/** Löscht die Sitzung serverseitig (nicht nur das Cookie), damit ein
+ *  abgefangener Token nicht mehr verwendbar ist. */
+export async function destroySession(): Promise<void> {
+  const store = await cookies();
+  const token = store.get(SESSION_COOKIE)?.value;
+  if (token) {
+    await query("delete from sessions where token_hash = $1", [hashToken(token)]);
+  }
+  store.delete(SESSION_COOKIE);
+}
+
+/** Wandelt UnauthorizedError/ForbiddenError in die passende JSON-Antwort
+ *  um; gibt null zurück, wenn err ein anderer Fehler ist (dann soll der
+ *  Aufrufer ihn weiterwerfen). Reduziert Wiederholung des immer gleichen
+ *  try/catch-Musters in den Route-Handlern. */
+export function authErrorResponse(err: unknown): Response | null {
+  if (err instanceof UnauthorizedError) {
+    return NextResponseJson({ error: "unauthorized" }, 401);
+  }
+  if (err instanceof ForbiddenError) {
+    return NextResponseJson({ error: "forbidden" }, 403);
+  }
+  return null;
+}
+
+function NextResponseJson(body: unknown, status: number): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+export { REFRESH_THRESHOLD_MS, hashToken, isSecureCookie };
@@ -0,0 +1,34 @@
+import "server-only";
+import { query, queryOne } from "@/lib/db";
+
+const CHALLENGE_TTL_MS = 5 * 60 * 1000;
+
+export type ChallengeType = "registration" | "authentication";
+
+export async function storeChallenge(
+  challenge: string,
+  type: ChallengeType,
+  userId: string | null
+): Promise<void> {
+  // Kein Cron nötig: abgelaufene Zeilen bei jeder neuen Challenge
+  // gleich mit aufräumen.
+  await query("delete from webauthn_challenges where expires_at < now()");
+  await query(
+    "insert into webauthn_challenges (user_id, challenge, type, expires_at) values ($1, $2, $3, $4)",
+    [userId, challenge, type, new Date(Date.now() + CHALLENGE_TTL_MS)]
+  );
+}
+
+/** Einmalig verwendbar: die Zeile wird beim Abruf sofort gelöscht. */
+export async function consumeChallenge(
+  challenge: string,
+  type: ChallengeType
+): Promise<{ userId: string | null } | null> {
+  const row = await queryOne<{ user_id: string | null }>(
+    `delete from webauthn_challenges
+     where challenge = $1 and type = $2 and expires_at > now()
+     returning user_id`,
+    [challenge, type]
+  );
+  return row ? { userId: row.user_id } : null;
+}
@@ -0,0 +1,19 @@
+import "server-only";
+
+// RP-Konfiguration wird direkt aus APP_URL/SITE_TITLE abgeleitet –
+// kein externer Konfigurationsschritt oder Cloud-API-Aufruf mehr nötig.
+function appUrl(): URL {
+  return new URL(process.env.APP_URL ?? "http://localhost:3000");
+}
+
+export function rpID(): string {
+  return appUrl().hostname;
+}
+
+export function origin(): string {
+  return appUrl().origin;
+}
+
+export function rpName(): string {
+  return process.env.SITE_TITLE?.trim() || "Canteen Menu";
+}
@@ -0,0 +1,48 @@
+import "server-only";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+// Logo/Favicon liegen als Dateien in einem lokalen Verzeichnis
+// (Docker-Volume in Produktion, s. docker-compose.yml).
+export function brandingDir(): string {
+  // turbopackIgnore: process.cwd() ist hier dynamisch, aber der Pfad
+  // bleibt statisch unter "data/branding" – ohne den Kommentar versucht
+  // Turbopack sonst, das gesamte Projektverzeichnis nach möglichen
+  // dynamischen require()-Zielen zu durchsuchen (harmlos, aber unnötig).
+  return (
+    process.env.BRANDING_DIR ??
+    path.join(/*turbopackIgnore: true*/ process.cwd(), "data", "branding")
+  );
+}
+
+// Nur einfache, von uns selbst vergebene Dateinamen zulassen
+// (`${kind}-${Date.now()}.${ext}`) – verhindert Path-Traversal über
+// Dateinamen aus der DB-Spalte logo_path/favicon_path.
+const SAFE_FILENAME = /^[a-zA-Z0-9_.-]+$/;
+
+export function isSafeFilename(filename: string): boolean {
+  return SAFE_FILENAME.test(filename) && !filename.includes("..");
+}
+
+export async function saveBrandingFile(filename: string, data: Buffer): Promise<void> {
+  const dir = brandingDir();
+  await mkdir(dir, { recursive: true });
+  await writeFile(path.join(dir, filename), data);
+}
+
+export async function readBrandingFile(filename: string): Promise<Buffer | null> {
+  if (!isSafeFilename(filename)) return null;
+  try {
+    return await readFile(path.join(brandingDir(), filename));
+  } catch {
+    return null;
+  }
+}
+
+export async function removeBrandingFile(filename: string): Promise<void> {
+  try {
+    await unlink(path.join(brandingDir(), filename));
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+  }
+}
@@ -0,0 +1,98 @@
+import "server-only";
+
+// Minimaler RFC-4180-artiger CSV-Parser/-Serializer für Import/Export der
+// Gerichte-/Allergen-/Zusatzstofflisten. Bewusst ohne npm-Abhängigkeit
+// (Projekt-Stil: kein ORM, keine Validierungs-Library, minimale Deps) –
+// deckt quoted Felder mit eingebetteten Kommas/Anführungszeichen/
+// Zeilenumbrüchen ab, da Gerichtsnamen Kommas enthalten können.
+
+export function parseCsv(text: string): string[][] {
+  const rows: string[][] = [];
+  let row: string[] = [];
+  let field = "";
+  let inQuotes = false;
+  let i = 0;
+  const len = text.length;
+
+  function pushField() {
+    row.push(field);
+    field = "";
+  }
+  function pushRow() {
+    pushField();
+    rows.push(row);
+    row = [];
+  }
+
+  while (i < len) {
+    const c = text[i];
+    if (inQuotes) {
+      if (c === '"') {
+        if (text[i + 1] === '"') {
+          field += '"';
+          i += 2;
+          continue;
+        }
+        inQuotes = false;
+        i++;
+        continue;
+      }
+      field += c;
+      i++;
+      continue;
+    }
+    if (c === '"') {
+      inQuotes = true;
+      i++;
+      continue;
+    }
+    if (c === ",") {
+      pushField();
+      i++;
+      continue;
+    }
+    if (c === "\r") {
+      i++;
+      continue;
+    }
+    if (c === "\n") {
+      pushRow();
+      i++;
+      continue;
+    }
+    field += c;
+    i++;
+  }
+  // Letzte Zeile ohne abschließenden Zeilenumbruch noch anhängen.
+  if (field !== "" || row.length > 0) pushRow();
+  // Leere Zeilen überspringen (z. B. durch einen abschließenden Zeilenumbruch).
+  return rows.filter((r) => !(r.length === 1 && r[0].trim() === ""));
+}
+
+function csvField(value: string): string {
+  if (/[",\r\n]/.test(value)) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+
+export function toCsv(rows: string[][]): string {
+  return rows.map((row) => row.map(csvField).join(",")).join("\r\n") + "\r\n";
+}
+
+/** Kopfzeile in Kleinbuchstaben, damit der Import tolerant gegenüber Groß-/
+ *  Kleinschreibung und Spaltenreihenfolge ist. */
+export function parseCsvWithHeader(text: string): { header: string[]; rows: string[][] } {
+  const table = parseCsv(text);
+  if (table.length === 0) return { header: [], rows: [] };
+  const [header, ...rows] = table;
+  return { header: header.map((h) => h.trim().toLowerCase()), rows };
+}
+
+/** Codes einer Zelle wie "A;G;2" in einzelne, getrimmte Kürzel zerlegen. */
+export function splitCodes(cell: string | undefined): string[] {
+  return (cell ?? "")
+    .split(";")
+    .map((c) => c.trim())
+    .filter(Boolean);
+}
@@ -0,0 +1,85 @@
+import "server-only";
+import { query, queryOne, withTransaction } from "@/lib/db";
+import type { CodeItem } from "@/lib/types";
+
+// "allergens"/"additives" sind identisch aufgebaute Tabellen (Kürzel +
+// Bezeichnung in DE/EN/PL). Tabellenname kommt nie aus Nutzereingaben,
+// sondern immer aus dem literal getypten Parameter unten – sicher für
+// String-Interpolation in der Query.
+export type CodeTable = "allergens" | "additives";
+
+export async function listCodes(table: CodeTable): Promise<CodeItem[]> {
+  return query<CodeItem>(`select * from ${table} order by sort`);
+}
+
+export async function createCode(
+  table: CodeTable,
+  input: { code: string; name: string; name_en: string | null; name_pl: string | null }
+): Promise<CodeItem> {
+  const maxRow = await queryOne<{ sort: number }>(
+    `select sort from ${table} order by sort desc limit 1`
+  );
+  return (await queryOne<CodeItem>(
+    `insert into ${table} (code, name, name_en, name_pl, sort) values ($1, $2, $3, $4, $5) returning *`,
+    [input.code, input.name, input.name_en, input.name_pl, (maxRow?.sort ?? 0) + 1]
+  ))!;
+}
+
+export async function updateCode(
+  table: CodeTable,
+  originalCode: string,
+  input: { code: string; name: string; name_en: string | null; name_pl: string | null }
+): Promise<CodeItem | null> {
+  return queryOne<CodeItem>(
+    `update ${table} set code = $1, name = $2, name_en = $3, name_pl = $4 where code = $5 returning *`,
+    [input.code, input.name, input.name_en, input.name_pl, originalCode]
+  );
+}
+
+export async function deleteCode(table: CodeTable, code: string): Promise<void> {
+  await query(`delete from ${table} where code = $1`, [code]);
+}
+
+export interface CodeImportRow {
+  code: string;
+  name: string;
+  name_en: string | null;
+  name_pl: string | null;
+}
+
+/** CSV-Import: legt neue Kürzel an, bestehende (gleicher Code) werden
+ *  aktualisiert – ein doppelter Code innerhalb derselben Datei
+ *  aktualisiert also einfach zweimal statt einen Fehler zu werfen. */
+export async function importCodes(
+  table: CodeTable,
+  rows: CodeImportRow[]
+): Promise<{ created: number; updated: number }> {
+  return withTransaction(async (client) => {
+    const existing = await client.query<{ code: string }>(`select code from ${table}`);
+    const known = new Set(existing.rows.map((r) => r.code));
+    const maxRow = await client.query<{ sort: number }>(
+      `select coalesce(max(sort), 0) as sort from ${table}`
+    );
+    let nextSort = (maxRow.rows[0]?.sort ?? 0) + 1;
+    let created = 0;
+    let updated = 0;
+
+    for (const row of rows) {
+      if (known.has(row.code)) {
+        await client.query(
+          `update ${table} set name = $1, name_en = $2, name_pl = $3 where code = $4`,
+          [row.name, row.name_en, row.name_pl, row.code]
+        );
+        updated++;
+      } else {
+        await client.query(
+          `insert into ${table} (code, name, name_en, name_pl, sort) values ($1, $2, $3, $4, $5)`,
+          [row.code, row.name, row.name_en, row.name_pl, nextSort++]
+        );
+        known.add(row.code);
+        created++;
+      }
+    }
+    return { created, updated };
+  });
+}
@@ -0,0 +1,36 @@
+import "server-only";
+import type { PoolClient, QueryResultRow } from "pg";
+import { pool } from "./pool";
+
+export async function query<T extends QueryResultRow = QueryResultRow>(
+  text: string,
+  params?: unknown[]
+): Promise<T[]> {
+  const result = await pool.query<T>(text, params);
+  return result.rows;
+}
+
+export async function queryOne<T extends QueryResultRow = QueryResultRow>(
+  text: string,
+  params?: unknown[]
+): Promise<T | null> {
+  const rows = await query<T>(text, params);
+  return rows[0] ?? null;
+}
+
+export async function withTransaction<T>(
+  fn: (client: PoolClient) => Promise<T>
+): Promise<T> {
+  const client = await pool.connect();
+  try {
+    await client.query("begin");
+    const result = await fn(client);
+    await client.query("commit");
+    return result;
+  } catch (err) {
+    await client.query("rollback");
+    throw err;
+  } finally {
+    client.release();
+  }
+}
@@ -0,0 +1,48 @@
+import "server-only";
+import { query } from "@/lib/db";
+import type { MenuEntry } from "@/lib/types";
+
+interface MenuEntryRow {
+  id: string;
+  menu_date: string;
+  section_key: string;
+  position: number;
+  dish_id: string;
+  name: string;
+  name_en: string | null;
+  name_pl: string | null;
+  price: string;
+  allergens: string[];
+  additives: string[];
+}
+
+/** Wochenplan-Einträge inkl. zugehörigem Gericht für den Zeitraum laden –
+ *  gemeinsam von der öffentlichen Speisekarte (Server Component) und
+ *  /api/menu-entries genutzt, damit der JOIN nur einmal gepflegt wird. */
+export async function loadMenuEntries(fromISO: string, toISO: string): Promise<MenuEntry[]> {
+  const rows = await query<MenuEntryRow>(
+    `select me.id, me.menu_date, me.section_key, me.position,
+            d.id as dish_id, d.name, d.name_en, d.name_pl, d.price, d.allergens, d.additives
+     from menu_entries me
+     join dishes d on d.id = me.dish_id
+     where me.menu_date between $1 and $2
+     order by me.position, me.created_at`,
+    [fromISO, toISO]
+  );
+
+  return rows.map((r) => ({
+    id: r.id,
+    menu_date: r.menu_date,
+    section_key: r.section_key,
+    position: r.position,
+    dish: {
+      id: r.dish_id,
+      name: r.name,
+      name_en: r.name_en,
+      name_pl: r.name_pl,
+      price: Number(r.price),
+      allergens: r.allergens,
+      additives: r.additives,
+    },
+  }));
+}
@@ -0,0 +1,28 @@
+import "server-only";
+import { Pool, types } from "pg";
+
+// pg gibt "date"-Spalten sonst als lokale Date-Objekte zurück (Zeitzonen-
+// Verschiebung möglich); die App vergleicht Datumswerte überall als reine
+// "YYYY-MM-DD"-Strings (siehe lib/menu.ts), daher Rohstring beibehalten.
+types.setTypeParser(types.builtins.DATE, (val) => val);
+
+// pg gibt "numeric" (dishes.price) sonst als String zurück (Precision-
+// Schutz), die App erwartet aber überall eine JS-Zahl (wie zuvor von
+// Postgrest geliefert) – für Preise im niedrigen vierstelligen Bereich
+// mit 2 Nachkommastellen unproblematisch.
+types.setTypeParser(types.builtins.NUMERIC, (val) => Number(val));
+
+// Next.js' Dev-Server lädt Module bei Hot-Reloads neu; ohne den
+// globalThis-Cache würde bei jedem Speichern ein neuer Pool (und damit
+// neue offene Verbindungen) entstehen.
+declare global {
+  var __pgPool: Pool | undefined;
+}
+
+export const pool =
+  globalThis.__pgPool ??
+  new Pool({ connectionString: process.env.DATABASE_URL });
+
+if (process.env.NODE_ENV !== "production") {
+  globalThis.__pgPool = pool;
+}
@@ -0,0 +1,22 @@
+import "server-only";
+import { queryOne } from "@/lib/db";
+
+export type LabelingMode = "detailed" | "notice";
+
+export interface Settings {
+  colors: Record<string, string>;
+  logo_path: string | null;
+  favicon_path: string | null;
+  labeling_mode: LabelingMode;
+  labeling_notice: string;
+  labeling_notice_en: string | null;
+  labeling_notice_pl: string | null;
+}
+
+export async function getSettings(): Promise<Settings | null> {
+  return queryOne<Settings>(
+    `select colors, logo_path, favicon_path, labeling_mode,
+            labeling_notice, labeling_notice_en, labeling_notice_pl
+     from settings where id = 1`
+  );
+}
@@ -37,21 +37,28 @@ const de = {
    users: "Benutzer",
    design: "Design",
    suggestions: "Vorschläge",
+    openSuggestions: "{count} offene Rezeptvorschläge",
    viewMenu: "Speisekarte ansehen",
    myAccount: "Mein Konto",
+    menuToggle: "Menü öffnen/schließen",
  },
  login: {
    title: "Anmeldung",
    submit: "Anmelden",
    or: "oder",
    passkeyButton: "Mit Passkey anmelden",
+    ssoButton: "Mit Single Sign-On anmelden",
    backToMenu: "← Zur Speisekarte",
    errorInvalidCredentials: "E-Mail-Adresse oder Passwort ist falsch.",
-    errorEmailNotConfirmed: "Die E-Mail-Adresse wurde noch nicht bestätigt.",
    errorPasskeyCancelled: "Passkey-Anmeldung wurde abgebrochen.",
    errorGeneric: "Anmeldung fehlgeschlagen: {message}",
    errorPasswordDisabled:
      "Die Anmeldung mit Passwort ist für dieses Konto deaktiviert. Bitte mit Passkey anmelden.",
+    errorOidcInvalidState:
+      "Die SSO-Anmeldung ist abgelaufen oder ungültig. Bitte erneut versuchen.",
+    errorOidcUnknownUser:
+      "Für diese E-Mail-Adresse existiert kein Konto. Bitte an die Verwaltung wenden.",
+    errorOidcFailed: "SSO-Anmeldung fehlgeschlagen. Bitte erneut versuchen.",
  },
  publicMenu: {
    prevWeek: "← Vorherige Woche",
@@ -63,13 +70,15 @@ const de = {
    weekTab: "Woche",
    allergens: "Allergene",
    additives: "Zusatzstoffe",
+    labelingNoticeTitle: "Allergene & Zusatzstoffe",
    suggestDish: "Rezept vorschlagen",
    noEntry: "–",
+    rssFeed: "RSS-Feed abonnieren",
  },
  weekEditor: {
    title: "Wochenplan",
    loading: "Lade Wochenplan…",
-    selectDish: "– Gericht wählen –",
+    changeDish: "Anderes Gericht wählen",
    addMeal: "Mahlzeit hinzufügen",
    newDishesHint: "Neue Gerichte legst du unter {link} an.",
    newDishesLinkLabel: "Gerichte",
@@ -105,6 +114,15 @@ const de = {
    loadError: "Laden fehlgeschlagen: {message}",
    saveError: "Speichern fehlgeschlagen: {message}",
    deleteError: "Löschen fehlgeschlagen: {message}",
+    exportButton: "Exportieren",
+    importButton: "Importieren",
+    exportError: "Export fehlgeschlagen: {message}",
+    importError: "Import fehlgeschlagen: {message}",
+    importSuccess: "{created} neu angelegt, {updated} aktualisiert.",
+    importSkipped: "{count} Zeile(n) übersprungen: {reasons}",
+    importSkippedRow: "Zeile {row}: {reason}",
+    labelingDisabledHint:
+      "Allergene/Zusatzstoffe sind aktuell deaktiviert (Hinweismodus aktiv, siehe „Allergene & Zusatzstoffe“).",
  },
  codeList: {
    allergensTitle: "Allergene",
@@ -118,6 +136,13 @@ const de = {
    loadError: "Laden fehlgeschlagen: {message}",
    saveError: "Speichern fehlgeschlagen: {message}",
    deleteError: "Löschen fehlgeschlagen: {message}",
+    exportButton: "Exportieren",
+    importButton: "Importieren",
+    exportError: "Export fehlgeschlagen: {message}",
+    importError: "Import fehlgeschlagen: {message}",
+    importSuccess: "{created} neu angelegt, {updated} aktualisiert.",
+    importSkipped: "{count} Zeile(n) übersprungen: {reasons}",
+    importSkippedRow: "Zeile {row}: {reason}",
  },
  sectionManager: {
    title: "Essenszeiten",
@@ -184,9 +209,23 @@ const de = {
    confirmRemoveLogo: "Logo wirklich entfernen?",
    confirmRemoveFavicon: "Favicon wirklich entfernen?",
  },
+  labelingNotice: {
+    title: "Anzeige von Allergenen & Zusatzstoffen",
+    hint:
+      "Standardmäßig sieht jeder Gast eine detaillierte Auswahl der Allergene/Zusatzstoffe je Gericht. Alternativ kann stattdessen nur ein Hinweistext angezeigt werden – die Auswahl je Gericht wird dann auch in der Gerichte-Verwaltung ausgeblendet.",
+    modeDetailed: "Detaillierte Auswahl je Gericht anzeigen",
+    modeNotice: "Nur Hinweistext anzeigen",
+    noticeDeLabel: "Hinweistext (Deutsch)",
+    noticeEnLabel: "Hinweistext (Englisch)",
+    noticePlLabel: "Hinweistext (Polnisch)",
+    save: "Speichern",
+    saved: "Gespeichert.",
+    loadError: "Laden fehlgeschlagen: {message}",
+    saveError: "Speichern fehlgeschlagen: {message}",
+  },
  passkeys: {
    title: "Passkeys",
-    hint: "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.",
+    hint: "Mit einem Passkey (Fingerabdruck, Gesichtserkennung oder Sicherheitsschlüssel) kannst du dich künftig ohne Passwort anmelden. Passkeys gelten pro Domain – nach einem Domainwechsel müssen sie neu registriert werden.",
    register: "Neuen Passkey registrieren",
    empty: "Noch keine Passkeys registriert.",
    createdOn: "– angelegt am {date}",
@@ -205,8 +244,7 @@ const de = {
    nameRequired: "Bitte einen Namen angeben.",
    emailTitle: "E-Mail-Adresse",
    changeEmail: "E-Mail-Adresse ändern",
-    emailSent:
-      "Bestätigungs-E-Mails wurden verschickt. Die neue Adresse wird erst nach Bestätigung des Links aktiv.",
+    emailChanged: "E-Mail-Adresse geändert.",
    passwordTitle: "Passwort ändern",
    currentPassword: "Aktuelles Passwort (zur Verifizierung)",
    newPassword: "Neues Passwort",
@@ -293,21 +331,27 @@ const en: Dict = {
    users: "Users",
    design: "Design",
    suggestions: "Suggestions",
+    openSuggestions: "{count} open dish suggestions",
    viewMenu: "View menu",
    myAccount: "My account",
+    menuToggle: "Open/close menu",
  },
  login: {
    title: "Sign in",
    submit: "Log in",
    or: "or",
    passkeyButton: "Sign in with passkey",
+    ssoButton: "Sign in with Single Sign-On",
    backToMenu: "← Back to menu",
    errorInvalidCredentials: "Email address or password is incorrect.",
-    errorEmailNotConfirmed: "This email address has not been confirmed yet.",
    errorPasskeyCancelled: "Passkey sign-in was cancelled.",
    errorGeneric: "Sign-in failed: {message}",
    errorPasswordDisabled:
      "Password sign-in is disabled for this account. Please sign in with a passkey.",
+    errorOidcInvalidState: "The SSO sign-in expired or was invalid. Please try again.",
+    errorOidcUnknownUser:
+      "No account exists for this email address. Please contact your administrator.",
+    errorOidcFailed: "SSO sign-in failed. Please try again.",
  },
  publicMenu: {
    prevWeek: "← Previous week",
@@ -319,13 +363,15 @@ const en: Dict = {
    weekTab: "Week",
    allergens: "Allergens",
    additives: "Additives",
+    labelingNoticeTitle: "Allergens & additives",
    suggestDish: "Suggest a dish",
    noEntry: "–",
+    rssFeed: "Subscribe to RSS feed",
  },
  weekEditor: {
    title: "Weekly plan",
    loading: "Loading weekly plan…",
-    selectDish: "– Select dish –",
+    changeDish: "Choose a different dish",
    addMeal: "Add meal",
    newDishesHint: "Add new dishes under {link}.",
    newDishesLinkLabel: "Dishes",
@@ -361,6 +407,15 @@ const en: Dict = {
    loadError: "Loading failed: {message}",
    saveError: "Saving failed: {message}",
    deleteError: "Deleting failed: {message}",
+    exportButton: "Export",
+    importButton: "Import",
+    exportError: "Export failed: {message}",
+    importError: "Import failed: {message}",
+    importSuccess: "{created} created, {updated} updated.",
+    importSkipped: "{count} row(s) skipped: {reasons}",
+    importSkippedRow: "Row {row}: {reason}",
+    labelingDisabledHint:
+      "Allergens/additives are currently disabled (notice mode active, see \"Allergens & additives\").",
  },
  codeList: {
    allergensTitle: "Allergens",
@@ -374,6 +429,13 @@ const en: Dict = {
    loadError: "Loading failed: {message}",
    saveError: "Saving failed: {message}",
    deleteError: "Deleting failed: {message}",
+    exportButton: "Export",
+    importButton: "Import",
+    exportError: "Export failed: {message}",
+    importError: "Import failed: {message}",
+    importSuccess: "{created} created, {updated} updated.",
+    importSkipped: "{count} row(s) skipped: {reasons}",
+    importSkippedRow: "Row {row}: {reason}",
  },
  sectionManager: {
    title: "Meal times",
@@ -440,9 +502,23 @@ const en: Dict = {
    confirmRemoveLogo: "Really remove the logo?",
    confirmRemoveFavicon: "Really remove the favicon?",
  },
+  labelingNotice: {
+    title: "Allergen & additive display",
+    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.",
+    modeDetailed: "Show detailed selection per dish",
+    modeNotice: "Show only notice text",
+    noticeDeLabel: "Notice text (German)",
+    noticeEnLabel: "Notice text (English)",
+    noticePlLabel: "Notice text (Polish)",
+    save: "Save",
+    saved: "Saved.",
+    loadError: "Loading failed: {message}",
+    saveError: "Saving failed: {message}",
+  },
  passkeys: {
    title: "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 – for production use, the domain must be configured in Supabase.",
+    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.",
    register: "Register new passkey",
    empty: "No passkeys registered yet.",
    createdOn: "– created on {date}",
@@ -461,8 +537,7 @@ const en: Dict = {
    nameRequired: "Please enter a name.",
    emailTitle: "Email address",
    changeEmail: "Change email address",
-    emailSent:
-      "Confirmation emails have been sent. The new address becomes active only after confirming the link.",
+    emailChanged: "Email address changed.",
    passwordTitle: "Change password",
    currentPassword: "Current password (for verification)",
    newPassword: "New password",
@@ -547,21 +622,28 @@ const pl: Dict = {
    users: "Użytkownicy",
    design: "Wygląd",
    suggestions: "Propozycje",
+    openSuggestions: "{count} otwartych propozycji dań",
    viewMenu: "Zobacz jadłospis",
    myAccount: "Moje konto",
+    menuToggle: "Otwórz/zamknij menu",
  },
  login: {
    title: "Logowanie",
    submit: "Zaloguj się",
    or: "lub",
    passkeyButton: "Zaloguj się kluczem dostępu",
+    ssoButton: "Zaloguj się przez Single Sign-On",
    backToMenu: "← Powrót do jadłospisu",
    errorInvalidCredentials: "Nieprawidłowy adres e-mail lub hasło.",
-    errorEmailNotConfirmed: "Adres e-mail nie został jeszcze potwierdzony.",
    errorPasskeyCancelled: "Logowanie kluczem dostępu zostało anulowane.",
    errorGeneric: "Logowanie nie powiodło się: {message}",
    errorPasswordDisabled:
      "Logowanie hasłem jest wyłączone dla tego konta. Zaloguj się kluczem dostępu.",
+    errorOidcInvalidState:
+      "Logowanie SSO wygasło lub jest nieprawidłowe. Spróbuj ponownie.",
+    errorOidcUnknownUser:
+      "Nie istnieje konto dla tego adresu e-mail. Skontaktuj się z administracją.",
+    errorOidcFailed: "Logowanie SSO nie powiodło się. Spróbuj ponownie.",
  },
  publicMenu: {
    prevWeek: "← Poprzedni tydzień",
@@ -573,13 +655,15 @@ const pl: Dict = {
    weekTab: "Tydzień",
    allergens: "Alergeny",
    additives: "Dodatki",
+    labelingNoticeTitle: "Alergeny i dodatki",
    suggestDish: "Zaproponuj danie",
    noEntry: "–",
+    rssFeed: "Subskrybuj kanał RSS",
  },
  weekEditor: {
    title: "Plan tygodnia",
    loading: "Wczytywanie planu tygodnia…",
-    selectDish: "– Wybierz danie –",
+    changeDish: "Wybierz inne danie",
    addMeal: "Dodaj posiłek",
    newDishesHint: "Nowe dania możesz dodać w zakładce {link}.",
    newDishesLinkLabel: "Dania",
@@ -615,6 +699,15 @@ const pl: Dict = {
    loadError: "Wczytywanie nie powiodło się: {message}",
    saveError: "Zapisywanie nie powiodło się: {message}",
    deleteError: "Usuwanie nie powiodło się: {message}",
+    exportButton: "Eksportuj",
+    importButton: "Importuj",
+    exportError: "Eksport nie powiódł się: {message}",
+    importError: "Import nie powiódł się: {message}",
+    importSuccess: "Utworzono: {created}, zaktualizowano: {updated}.",
+    importSkipped: "Pominięto wierszy: {count}: {reasons}",
+    importSkippedRow: "Wiersz {row}: {reason}",
+    labelingDisabledHint:
+      "Alergeny/dodatki są obecnie wyłączone (aktywny tryb komunikatu, patrz „Alergeny i dodatki”).",
  },
  codeList: {
    allergensTitle: "Alergeny",
@@ -628,6 +721,13 @@ const pl: Dict = {
    loadError: "Wczytywanie nie powiodło się: {message}",
    saveError: "Zapisywanie nie powiodło się: {message}",
    deleteError: "Usuwanie nie powiodło się: {message}",
+    exportButton: "Eksportuj",
+    importButton: "Importuj",
+    exportError: "Eksport nie powiódł się: {message}",
+    importError: "Import nie powiódł się: {message}",
+    importSuccess: "Utworzono: {created}, zaktualizowano: {updated}.",
+    importSkipped: "Pominięto wierszy: {count}: {reasons}",
+    importSkippedRow: "Wiersz {row}: {reason}",
  },
  sectionManager: {
    title: "Pory posiłków",
@@ -694,9 +794,23 @@ const pl: Dict = {
    confirmRemoveLogo: "Czy na pewno usunąć logo?",
    confirmRemoveFavicon: "Czy na pewno usunąć favicon?",
  },
+  labelingNotice: {
+    title: "Wyświetlanie alergenów i dodatków",
+    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.",
+    modeDetailed: "Pokaż szczegółowy wybór dla każdego dania",
+    modeNotice: "Pokaż tylko komunikat",
+    noticeDeLabel: "Tekst komunikatu (niemiecki)",
+    noticeEnLabel: "Tekst komunikatu (angielski)",
+    noticePlLabel: "Tekst komunikatu (polski)",
+    save: "Zapisz",
+    saved: "Zapisano.",
+    loadError: "Wczytywanie nie powiodło się: {message}",
+    saveError: "Zapisywanie nie powiodło się: {message}",
+  },
  passkeys: {
    title: "Klucze dostępu",
-    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 – w środowisku produkcyjnym domena musi być skonfigurowana w Supabase.",
+    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.",
    register: "Zarejestruj nowy klucz dostępu",
    empty: "Nie zarejestrowano jeszcze żadnych kluczy dostępu.",
    createdOn: "– utworzono {date}",
@@ -715,8 +829,7 @@ const pl: Dict = {
    nameRequired: "Podaj nazwę.",
    emailTitle: "Adres e-mail",
    changeEmail: "Zmień adres e-mail",
-    emailSent:
-      "Wysłano e-maile potwierdzające. Nowy adres zacznie obowiązywać dopiero po potwierdzeniu linku.",
+    emailChanged: "Adres e-mail zmieniony.",
    passwordTitle: "Zmień hasło",
    currentPassword: "Obecne hasło (do weryfikacji)",
    newPassword: "Nowe hasło",
@@ -1,8 +1,8 @@
 // CSRF-Schutz (Defense-in-Depth) für schreibende Route-Handler:
 // Browser senden bei Cross-Site-POSTs immer einen Origin-Header –
 // stimmt er nicht mit dem Host überein, wird die Anfrage abgelehnt.
-// (Erste Verteidigungslinie sind bereits die SameSite=Lax-Session-
-// Cookies von @supabase/ssr sowie der JSON-Content-Type.)
+// (Erste Verteidigungslinie ist bereits das SameSite=Lax-Session-Cookie,
+// siehe lib/auth/session.ts, sowie der JSON-Content-Type.)
 export function isSameOrigin(request: Request): boolean {
  const origin = request.headers.get("origin");
  // Kein Origin-Header: kein Browser-Cross-Site-Kontext (z. B. curl);
@@ -1,14 +0,0 @@
-import "server-only";
-import { createClient as createSupabaseClient } from "@supabase/supabase-js";
-
-// Service-Role-Client: umgeht RLS. Ausschließlich serverseitig verwenden
-// (Benutzerverwaltung durch den Admin).
-export function createAdminClient() {
-  return createSupabaseClient(
-    process.env.NEXT_PUBLIC_SUPABASE_URL!,
-    process.env.SUPABASE_SERVICE_ROLE_KEY!,
-    {
-      auth: { persistSession: false, autoRefreshToken: false },
-    }
-  );
-}
@@ -1,15 +0,0 @@
-import { createBrowserClient } from "@supabase/ssr";
-
-// Browser-Client (Client Components). Passkey-Support ist bei Supabase
-// derzeit als experimentelles Feature markiert und muss aktiviert werden.
-export function createClient() {
-  return createBrowserClient(
-    process.env.NEXT_PUBLIC_SUPABASE_URL!,
-    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
-    {
-      auth: {
-        experimental: { passkey: true },
-      },
-    }
-  );
-}
@@ -1,30 +0,0 @@
-import { createServerClient } from "@supabase/ssr";
-import { cookies } from "next/headers";
-
-// Server-Client (Server Components, Route Handler, Server Actions).
-// Muss pro Request neu erzeugt werden.
-export async function createClient() {
-  const cookieStore = await cookies();
-
-  return createServerClient(
-    process.env.NEXT_PUBLIC_SUPABASE_URL!,
-    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
-    {
-      cookies: {
-        getAll() {
-          return cookieStore.getAll();
-        },
-        setAll(cookiesToSet) {
-          try {
-            cookiesToSet.forEach(({ name, value, options }) =>
-              cookieStore.set(name, value, options)
-            );
-          } catch {
-            // In Server Components dürfen keine Cookies gesetzt werden –
-            // das Session-Refresh übernimmt proxy.ts.
-          }
-        },
-      },
-    }
-  );
-}
@@ -87,12 +87,12 @@ export const COLOR_VARS: Record<string, string> = {

 export function logoUrl(path: string | null | undefined): string | null {
  if (!path) return null;
-  return `${process.env.NEXT_PUBLIC_SUPABASE_URL}/storage/v1/object/public/branding/${path}`;
+  return `/branding/${path}`;
 }

 export function faviconUrl(path: string | null | undefined): string | null {
  if (!path) return null;
-  return `${process.env.NEXT_PUBLIC_SUPABASE_URL}/storage/v1/object/public/branding/${path}`;
+  return `/branding/${path}`;
 }

 export const SITE_TITLE = process.env.SITE_TITLE?.trim() || "Canteen Menu";
@@ -1,16 +1,18 @@
 {
  "name": "canteen-menu",
-  "version": "1.4.0",
+  "version": "1.9.5",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "canteen-menu",
-      "version": "1.4.0",
+      "version": "1.9.5",
      "dependencies": {
-        "@supabase/ssr": "^0.12.3",
-        "@supabase/supabase-js": "^2.110.7",
+        "@simplewebauthn/browser": "^13.3.0",
+        "@simplewebauthn/server": "^13.3.2",
+        "jose": "^6.2.3",
        "next": "16.2.10",
+        "pg": "^8.22.0",
        "react": "19.2.4",
        "react-dom": "19.2.4",
        "server-only": "^0.0.1"
@@ -18,6 +20,7 @@
      "devDependencies": {
        "@tailwindcss/postcss": "^4",
        "@types/node": "^20",
+        "@types/pg": "^8.20.0",
        "@types/react": "^19",
        "@types/react-dom": "^19",
        "eslint": "^9",
@@ -456,6 +459,12 @@
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      }
    },
+    "node_modules/@hexagon/base64": {
+      "version": "1.1.28",
+      "resolved": "https://registry.npmjs.org/@hexagon/base64/-/base64-1.1.28.tgz",
+      "integrity": "sha512-lhqDEAvWixy3bZ+UOYbPwUbBkwBq5C1LAJ/xPC8Oi+lL54oyakv/npbA0aU2hgCsx/1NUd4IBvV03+aUBWxerw==",
+      "license": "MIT"
+    },
    "node_modules/@humanfs/core": {
      "version": "0.19.2",
      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz",
@@ -1086,6 +1095,12 @@
        "@jridgewell/sourcemap-codec": "^1.4.14"
      }
    },
+    "node_modules/@levischuck/tiny-cbor": {
+      "version": "0.2.11",
+      "resolved": "https://registry.npmjs.org/@levischuck/tiny-cbor/-/tiny-cbor-0.2.11.tgz",
+      "integrity": "sha512-llBRm4dT4Z89aRsm6u2oEZ8tfwL/2l6BwpZ7JcyieouniDECM5AqNgr/y08zalEIvW3RSK4upYyybDcmjXqAow==",
+      "license": "MIT"
+    },
    "node_modules/@napi-rs/wasm-runtime": {
      "version": "1.1.6",
      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.6.tgz",
@@ -1309,6 +1324,174 @@
        "node": ">=12.4.0"
      }
    },
+    "node_modules/@peculiar/asn1-android": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-android/-/asn1-android-2.8.0.tgz",
+      "integrity": "sha512-skLbS+IOGv1lUgDqtChr8xvtvEr3HMse/JGBaL2r1J1o/n7a8wqOrovMtlRq/UXLhxvmLaONP67hwtshgzwfzA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-cms": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-cms/-/asn1-cms-2.8.0.tgz",
+      "integrity": "sha512-NgekZOrSJFSBFLFoLfwePguAWAx7z1+f2TEsWFUMyiqqfntZ4+S/S5hzqME3q4pCA0iOsFKdwiQ35dwY24eVqA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "@peculiar/asn1-x509-attr": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-csr": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-csr/-/asn1-csr-2.8.0.tgz",
+      "integrity": "sha512-akbF8+uvleHs8sejNPQxwmVFuInAg6FMNHOwMILXfP518YfFJwdR3jr6oNUPOaEJfuEhn/vkNOCIT6ASUd4mbg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-ecc": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-ecc/-/asn1-ecc-2.8.0.tgz",
+      "integrity": "sha512-ohwlk+u9Rv2NOAY1c6MfHj45ATVF8R1DUN/WCgABiRtLi2ZftlZWZX7KvpAbU8v9xPcmoILfELeEABj/rn18AQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-pfx": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pfx/-/asn1-pfx-2.8.0.tgz",
+      "integrity": "sha512-5yof1ytoB++RQtaFbqSUJ8pxDJtZT6vbVqZ8XoJ61ph7UjNVvfFwAilnCodqkNsAodpy13gDhoxZXw00pghnyg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.8.0",
+        "@peculiar/asn1-pkcs8": "^2.8.0",
+        "@peculiar/asn1-rsa": "^2.8.0",
+        "@peculiar/asn1-schema": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-pkcs8": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs8/-/asn1-pkcs8-2.8.0.tgz",
+      "integrity": "sha512-qAKXtLpBEw9LqhKpjw3ajZSXlBur+ipW+y2ivVBQAG6F6qRx94yO+1ZR4mvw+YaCfKSaOzLeYEzsPaBp4SJELA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-pkcs9": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs9/-/asn1-pkcs9-2.8.0.tgz",
+      "integrity": "sha512-b5nDWCnkV60+cQ141D6sVVwK9nz64R5n3zSVnklGd+ECdkW2Ol3U1a6yYFlalpSOaD557yuJB64A+q42jG7lUQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.8.0",
+        "@peculiar/asn1-pfx": "^2.8.0",
+        "@peculiar/asn1-pkcs8": "^2.8.0",
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "@peculiar/asn1-x509-attr": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-rsa": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-rsa/-/asn1-rsa-2.8.0.tgz",
+      "integrity": "sha512-zHEUlCqB2mk7x2lxDwHHJy7hWZOPdGHVlsmITWKB5/PbQo61atbu9PJ/0r9dQNMwFzbKPXZ8uK8/91eUhRznSg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-schema": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-schema/-/asn1-schema-2.8.0.tgz",
+      "integrity": "sha512-7YT0U/ze0tF2QOBbE15gKZwy5tvgGyLRiRHLzhlbOpf7BT032oBSd0haZqXn5W6l26WLlu3dyxzjM+2638/z2Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/utils": "^2.0.2",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-x509": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509/-/asn1-x509-2.8.0.tgz",
+      "integrity": "sha512-N0CMuhWUzsWEVq6F1q9X6+VKUnWzSW+cSVg+aPaGGwDdbFoFWTYgin5MHwXgpWd6y9COMBxnfy/Qc+Xc7F0Zwg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/utils": "^2.0.2",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-x509-attr": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509-attr/-/asn1-x509-attr-2.8.0.tgz",
+      "integrity": "sha512-tHjkfS/qhMnmrlB2J9NhflQlQ7In3khO3CfmVrriOlpTeErY9ZIKOso1hQ5JQiyrJ7ShvqVPk7E5fQmbclkSKA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/utils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@peculiar/utils/-/utils-2.0.3.tgz",
+      "integrity": "sha512-+oL3HPFRIZ1St2K50lWCXiioIgSoxzz7R1J3uF6neO2yl1sgmpgY6XXJH4BdpoDkMWznQTeYF6oWNDZLCdQ4eQ==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/x509": {
+      "version": "1.14.3",
+      "resolved": "https://registry.npmjs.org/@peculiar/x509/-/x509-1.14.3.tgz",
+      "integrity": "sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.6.0",
+        "@peculiar/asn1-csr": "^2.6.0",
+        "@peculiar/asn1-ecc": "^2.6.0",
+        "@peculiar/asn1-pkcs9": "^2.6.0",
+        "@peculiar/asn1-rsa": "^2.6.0",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.0",
+        "pvtsutils": "^1.3.6",
+        "reflect-metadata": "^0.2.2",
+        "tslib": "^2.8.1",
+        "tsyringe": "^4.10.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
    "node_modules/@rtsao/scc": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz",
@@ -1316,100 +1499,29 @@
      "dev": true,
      "license": "MIT"
    },
-    "node_modules/@supabase/auth-js": {
-      "version": "2.110.7",
-      "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.110.7.tgz",
-      "integrity": "sha512-M5Bpl4hCv6kHcOO/xM06Dyfg1mYLHljMkp1plhzG9IRZPc3czvyMsSN1XpL5+GKisOKM3lSN59zhpcm6sMVXfA==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "2.8.1"
-      },
-      "engines": {
-        "node": ">=22.0.0"
-      }
-    },
-    "node_modules/@supabase/functions-js": {
-      "version": "2.110.7",
-      "resolved": "https://registry.npmjs.org/@supabase/functions-js/-/functions-js-2.110.7.tgz",
-      "integrity": "sha512-megYmexlYEoR/0qlsr4Snh9wtzAodO7MAri3NMevZrXzNvQRKlvmTcSBoKGLQEPDakgDZMqbMdf9DwoZz6qfoA==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "2.8.1"
-      },
-      "engines": {
-        "node": ">=22.0.0"
-      }
-    },
-    "node_modules/@supabase/phoenix": {
-      "version": "0.4.5",
-      "resolved": "https://registry.npmjs.org/@supabase/phoenix/-/phoenix-0.4.5.tgz",
-      "integrity": "sha512-aAn9H9ovVyeApKy11OWOrrOGq8DV68yWeH4ud2lN9fzn4aO8Zb5GLL9m1pUg9nLqIcT+ZDfAcsZe0E/nqdv2lw==",
+    "node_modules/@simplewebauthn/browser": {
+      "version": "13.3.0",
+      "resolved": "https://registry.npmjs.org/@simplewebauthn/browser/-/browser-13.3.0.tgz",
+      "integrity": "sha512-BE/UWv6FOToAdVk0EokzkqQQDOWtNydYlY6+OrmiZ5SCNmb41VehttboTetUM3T/fr6EAFYVXjz4My2wg230rQ==",
      "license": "MIT"
    },
-    "node_modules/@supabase/postgrest-js": {
-      "version": "2.110.7",
-      "resolved": "https://registry.npmjs.org/@supabase/postgrest-js/-/postgrest-js-2.110.7.tgz",
-      "integrity": "sha512-ban6YV0djhVaqVYezlOARKLIuOBSvLLhyQVZjA2nxPrtswhxHCl1+gI4giFgI9ATQAaMNbUZb4JXiuL5lEA/5g==",
+    "node_modules/@simplewebauthn/server": {
+      "version": "13.3.2",
+      "resolved": "https://registry.npmjs.org/@simplewebauthn/server/-/server-13.3.2.tgz",
+      "integrity": "sha512-KEDhfcGP1PAKRVSDjA3npTQFqS2b/srm+ipoNBNHdkzrHAlaRQUTE+a5f4ywsx6thxAw1NU2rYcLEY1949RGbQ==",
      "license": "MIT",
      "dependencies": {
-        "tslib": "2.8.1"
+        "@hexagon/base64": "^1.1.27",
+        "@levischuck/tiny-cbor": "^0.2.2",
+        "@peculiar/asn1-android": "^2.6.0",
+        "@peculiar/asn1-ecc": "^2.6.1",
+        "@peculiar/asn1-rsa": "^2.6.1",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "@peculiar/x509": "^1.14.3"
      },
      "engines": {
-        "node": ">=22.0.0"
-      }
-    },
-    "node_modules/@supabase/realtime-js": {
-      "version": "2.110.7",
-      "resolved": "https://registry.npmjs.org/@supabase/realtime-js/-/realtime-js-2.110.7.tgz",
-      "integrity": "sha512-AMtZjyFA2gsmjuxopPNS/sRznLQHG0Ht5x+ytTPTOh3vAcOTUlVRLx7gW4/CONNnbb3PKOkE+HmM35HOSbmomQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@supabase/phoenix": "0.4.5",
-        "tslib": "2.8.1"
-      },
-      "engines": {
-        "node": ">=22.0.0"
-      }
-    },
-    "node_modules/@supabase/ssr": {
-      "version": "0.12.3",
-      "resolved": "https://registry.npmjs.org/@supabase/ssr/-/ssr-0.12.3.tgz",
-      "integrity": "sha512-qWXJ/dI7CiYDKyTgIPqJ4Qkh8y5edh2LdF/nkN48z47mmEVzAO2OE+YErYeQ/UemVfonn/F4kFz+lhLqoVMdpw==",
-      "license": "MIT",
-      "dependencies": {
-        "cookie": "^1.0.2"
-      },
-      "peerDependencies": {
-        "@supabase/supabase-js": "^2.110.5"
-      }
-    },
-    "node_modules/@supabase/storage-js": {
-      "version": "2.110.7",
-      "resolved": "https://registry.npmjs.org/@supabase/storage-js/-/storage-js-2.110.7.tgz",
-      "integrity": "sha512-2tcDE8cjEDy1uKxKavBpKQod1JdMV1jDXQag48TCa+kycmJOltc0yVabC0BUlhOwAl6WykXU2aOsH3ELMtZrmQ==",
-      "license": "MIT",
-      "dependencies": {
-        "iceberg-js": "^0.8.1",
-        "tslib": "2.8.1"
-      },
-      "engines": {
-        "node": ">=22.0.0"
-      }
-    },
-    "node_modules/@supabase/supabase-js": {
-      "version": "2.110.7",
-      "resolved": "https://registry.npmjs.org/@supabase/supabase-js/-/supabase-js-2.110.7.tgz",
-      "integrity": "sha512-AnfO3A230Shy6RMO7cya3Wl1OcXnABJrzH8vP+fY7/RFjhzcchB7DjKkkTIAntlwekD+GkSFzEvt2tC+D4Fp8w==",
-      "license": "MIT",
-      "dependencies": {
-        "@supabase/auth-js": "2.110.7",
-        "@supabase/functions-js": "2.110.7",
-        "@supabase/postgrest-js": "2.110.7",
-        "@supabase/realtime-js": "2.110.7",
-        "@supabase/storage-js": "2.110.7"
-      },
-      "engines": {
-        "node": ">=22.0.0"
+        "node": ">=20.0.0"
      }
    },
    "node_modules/@swc/helpers": {
@@ -1656,6 +1768,72 @@
        "node": ">=14.0.0"
      }
    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/core": {
+      "version": "1.11.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.2",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/runtime": {
+      "version": "1.11.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.2",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.1.4",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@tybys/wasm-util": "^0.10.1"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "peerDependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@tybys/wasm-util": {
+      "version": "0.10.2",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/tslib": {
+      "version": "2.8.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "0BSD",
+      "optional": true
+    },
    "node_modules/@tailwindcss/oxide-win32-arm64-msvc": {
      "version": "4.3.3",
      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.3.3.tgz",
@@ -1746,6 +1924,18 @@
        "undici-types": "~6.21.0"
      }
    },
+    "node_modules/@types/pg": {
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/@types/pg/-/pg-8.20.0.tgz",
+      "integrity": "sha512-bEPFOaMAHTEP1EzpvHTbmwR8UsFyHSKsRisLIHVMXnpNefSbGA1bD6CVy+qKjGSqmZqNqBDV2azOBo8TgkcVow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "pg-protocol": "*",
+        "pg-types": "^2.2.0"
+      }
+    },
    "node_modules/@types/react": {
      "version": "19.2.17",
      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.17.tgz",
@@ -2648,6 +2838,20 @@
        "url": "https://github.com/sponsors/ljharb"
      }
    },
+    "node_modules/asn1js": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/asn1js/-/asn1js-3.0.10.tgz",
+      "integrity": "sha512-S2s3aOytiKdFRdulw2qPE51MzjzVOisppcVv7jVFR+Kw0kxwvFrDcYA0h7Ndqbmj0HkMIXYWaoj7fli8kgx1eg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "pvtsutils": "^1.3.6",
+        "pvutils": "^1.1.5",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
    "node_modules/ast-types-flow": {
      "version": "0.0.8",
      "resolved": "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.8.tgz",
@@ -2915,19 +3119,6 @@
      "dev": true,
      "license": "MIT"
    },
-    "node_modules/cookie": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.1.1.tgz",
-      "integrity": "sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
    "node_modules/cross-spawn": {
      "version": "7.0.6",
      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
@@ -4215,15 +4406,6 @@
        "hermes-estree": "0.25.1"
      }
    },
-    "node_modules/iceberg-js": {
-      "version": "0.8.1",
-      "resolved": "https://registry.npmjs.org/iceberg-js/-/iceberg-js-0.8.1.tgz",
-      "integrity": "sha512-1dhVQZXhcHje7798IVM+xoo/1ZdVfzOMIc8/rgVSijRK38EDqOJoGula9N/8ZI5RD8QTxNQtK/Gozpr+qUqRRA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=20.0.0"
-      }
-    },
    "node_modules/ignore": {
      "version": "5.3.2",
      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
@@ -4749,6 +4931,15 @@
        "jiti": "lib/jiti-cli.mjs"
      }
    },
+    "node_modules/jose": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.3.tgz",
+      "integrity": "sha512-YYVDInQKFJfR/xa3ojUTl8c2KoTwiL1R5Wg9YCydwH0x0B9grbzlg5HC7mMjCtUJjbQ/YnGEZIhI5tCgfTb4Hw==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
    "node_modules/js-tokens": {
      "version": "4.0.0",
      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
@@ -5661,6 +5852,95 @@
      "dev": true,
      "license": "MIT"
    },
+    "node_modules/pg": {
+      "version": "8.22.0",
+      "resolved": "https://registry.npmjs.org/pg/-/pg-8.22.0.tgz",
+      "integrity": "sha512-8wih1vVIBMxoUM2oB4soJsD9tDnDpLv4OXBJ+EJzFsvycD+lfyIreC2gGHq78f8jbLLt+bvlPTFdFZfJkOuzAA==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-connection-string": "^2.14.0",
+        "pg-pool": "^3.14.0",
+        "pg-protocol": "^1.15.0",
+        "pg-types": "2.2.0",
+        "pgpass": "1.0.5"
+      },
+      "engines": {
+        "node": ">= 16.0.0"
+      },
+      "optionalDependencies": {
+        "pg-cloudflare": "^1.4.0"
+      },
+      "peerDependencies": {
+        "pg-native": ">=3.0.1"
+      },
+      "peerDependenciesMeta": {
+        "pg-native": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/pg-cloudflare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.4.0.tgz",
+      "integrity": "sha512-Vo7z/6rrQYxpNRylp4Tlob2elzbh+N/MOQbxFVWCxS7oEx6jF53GTJFxK2WWpKuBRkmiin4Mt+xofFDjx09R0A==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/pg-connection-string": {
+      "version": "2.14.0",
+      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.14.0.tgz",
+      "integrity": "sha512-XwWDGcLRGCXAR8F/AM5bG7Q+A3Wm2s6QeEjlOKZLlH3UYcguiqCWKyWXVag5TLTIjR7oOJUY8kcADaZgWPyLeg==",
+      "license": "MIT"
+    },
+    "node_modules/pg-int8": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz",
+      "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/pg-pool": {
+      "version": "3.14.0",
+      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.14.0.tgz",
+      "integrity": "sha512-gKtPkFdQPU3DksooVLi9LsjZxrsBUZIpa+7aVx+LV5pNh0KzP4Zleud2po+ConrxbuXGBJ6Hfer6hdgpIBpBaw==",
+      "license": "MIT",
+      "peerDependencies": {
+        "pg": ">=8.0"
+      }
+    },
+    "node_modules/pg-protocol": {
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.15.0.tgz",
+      "integrity": "sha512-cq9sECI5s0+uPUXjbz8ioyPJni6RzsRib0US67i5IoTZKw8fNeYlVE7u8F4dG7vEJJtc5wdD1K189lCCUwqWTQ==",
+      "license": "MIT"
+    },
+    "node_modules/pg-types": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz",
+      "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-int8": "1.0.1",
+        "postgres-array": "~2.0.0",
+        "postgres-bytea": "~1.0.0",
+        "postgres-date": "~1.0.4",
+        "postgres-interval": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/pgpass": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz",
+      "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==",
+      "license": "MIT",
+      "dependencies": {
+        "split2": "^4.1.0"
+      }
+    },
    "node_modules/picocolors": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -5719,6 +5999,45 @@
        "node": "^10 || ^12 || >=14"
      }
    },
+    "node_modules/postgres-array": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz",
+      "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postgres-bytea": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.1.tgz",
+      "integrity": "sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-date": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz",
+      "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-interval": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz",
+      "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==",
+      "license": "MIT",
+      "dependencies": {
+        "xtend": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
    "node_modules/prelude-ls": {
      "version": "1.2.1",
      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
@@ -5751,6 +6070,24 @@
        "node": ">=6"
      }
    },
+    "node_modules/pvtsutils": {
+      "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/pvtsutils/-/pvtsutils-1.3.6.tgz",
+      "integrity": "sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/pvutils": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/pvutils/-/pvutils-1.1.5.tgz",
+      "integrity": "sha512-KTqnxsgGiQ6ZAzZCVlJH5eOjSnvlyEgx1m8bkRJfOhmGRqfo5KLvmAlACQkrjEtOQ4B7wF9TdSLIs9O90MX9xA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
    "node_modules/queue-microtask": {
      "version": "1.2.3",
      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
@@ -5800,6 +6137,12 @@
      "dev": true,
      "license": "MIT"
    },
+    "node_modules/reflect-metadata": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz",
+      "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==",
+      "license": "Apache-2.0"
+    },
    "node_modules/reflect.getprototypeof": {
      "version": "1.0.10",
      "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
@@ -6215,6 +6558,15 @@
        "node": ">=0.10.0"
      }
    },
+    "node_modules/split2": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">= 10.x"
+      }
+    },
    "node_modules/stable-hash": {
      "version": "0.0.5",
      "resolved": "https://registry.npmjs.org/stable-hash/-/stable-hash-0.0.5.tgz",
@@ -6549,6 +6901,24 @@
      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
      "license": "0BSD"
    },
+    "node_modules/tsyringe": {
+      "version": "4.10.0",
+      "resolved": "https://registry.npmjs.org/tsyringe/-/tsyringe-4.10.0.tgz",
+      "integrity": "sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^1.9.3"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/tsyringe/node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "license": "0BSD"
+    },
    "node_modules/type-check": {
      "version": "0.4.0",
      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
@@ -6898,6 +7268,15 @@
        "node": ">=0.10.0"
      }
    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4"
+      }
+    },
    "node_modules/yallist": {
      "version": "3.1.1",
      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
@@ -1,17 +1,23 @@
 {
  "name": "canteen-menu",
-  "version": "1.4.0",
+  "version": "1.9.5",
  "private": true,
  "scripts": {
+    "predev": "node --env-file-if-exists=.env.local db/migrate.mjs && node --env-file-if-exists=.env.local scripts/bootstrap-admin.mjs",
    "dev": "next dev -H 0.0.0.0",
    "build": "next build",
+    "prestart": "node --env-file-if-exists=.env.local db/migrate.mjs && node --env-file-if-exists=.env.local scripts/bootstrap-admin.mjs",
    "start": "next start -H 0.0.0.0",
-    "lint": "eslint"
+    "lint": "eslint",
+    "db:migrate": "node --env-file-if-exists=.env.local db/migrate.mjs",
+    "db:seed-demo": "node --env-file-if-exists=.env.local db/seed-demo.mjs"
  },
  "dependencies": {
-    "@supabase/ssr": "^0.12.3",
-    "@supabase/supabase-js": "^2.110.7",
+    "@simplewebauthn/browser": "^13.3.0",
+    "@simplewebauthn/server": "^13.3.2",
+    "jose": "^6.2.3",
    "next": "16.2.10",
+    "pg": "^8.22.0",
    "react": "19.2.4",
    "react-dom": "19.2.4",
    "server-only": "^0.0.1"
@@ -19,6 +25,7 @@
  "devDependencies": {
    "@tailwindcss/postcss": "^4",
    "@types/node": "^20",
+    "@types/pg": "^8.20.0",
    "@types/react": "^19",
    "@types/react-dom": "^19",
    "eslint": "^9",
@@ -1,36 +1,36 @@
-import { createServerClient } from "@supabase/ssr";
+import { createHash } from "node:crypto";
 import { NextResponse, type NextRequest } from "next/server";
+import { Pool } from "pg";

 // Session-Refresh + Zugriffsschutz für die internen Bereiche.
+// Next 16 führt Proxy standardmäßig im Node.js-Runtime aus, direkter
+// pg-Zugriff ist hier also möglich (kein Edge-Workaround nötig).
+//
+// Der Cookie-Name ist hier bewusst dupliziert statt aus lib/auth/session
+// importiert: dieses Modul zieht next/headers (cookies()) nach, das
+// außerhalb von Server Components/Route Handlern/Server Actions nicht
+// nutzbar ist – Proxy läuft in einem eigenen Ausführungskontext.
+const SESSION_COOKIE = "session";
+
+declare global {
+  var __pgPoolProxy: Pool | undefined;
+}
+const pool =
+  globalThis.__pgPoolProxy ??
+  new Pool({ connectionString: process.env.DATABASE_URL });
+if (process.env.NODE_ENV !== "production") globalThis.__pgPoolProxy = pool;
+
+const REFRESH_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1000;
+const SESSION_LIFETIME_MS = 30 * 24 * 60 * 60 * 1000;
+
+function hashToken(token: string): string {
+  return createHash("sha256").update(token).digest("hex");
+}
+
 export async function proxy(request: NextRequest) {
-  let response = NextResponse.next({ request });
+  const token = request.cookies.get(SESSION_COOKIE)?.value;

-  const supabase = createServerClient(
-    process.env.NEXT_PUBLIC_SUPABASE_URL!,
-    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
-    {
-      cookies: {
-        getAll() {
-          return request.cookies.getAll();
-        },
-        setAll(cookiesToSet) {
-          cookiesToSet.forEach(({ name, value }) =>
-            request.cookies.set(name, value)
-          );
-          response = NextResponse.next({ request });
-          cookiesToSet.forEach(({ name, value, options }) =>
-            response.cookies.set(name, value, options)
-          );
-        },
-      },
-    }
-  );
-
-  const {
-    data: { user },
-  } = await supabase.auth.getUser();
-
-  if (!user) {
+  function redirectToLogin() {
    // Absolute URL aus dem Host-Header des Browsers bauen: request.nextUrl
    // trägt bei "-H 0.0.0.0" die Server-Bindung statt des aufgerufenen
    // Hosts, und relative Location-Header lehnt die Middleware ab.
@@ -41,6 +41,36 @@ export async function proxy(request: NextRequest) {
    return NextResponse.redirect(`${proto}://${host}/login`, 303);
  }

+  if (!token) return redirectToLogin();
+
+  const tokenHash = hashToken(token);
+  const { rows } = await pool.query<{ expires_at: Date }>(
+    "select expires_at from sessions where token_hash = $1 and expires_at > now()",
+    [tokenHash]
+  );
+  const session = rows[0];
+  if (!session) return redirectToLogin();
+
+  const response = NextResponse.next();
+
+  // Sliding-Refresh: bei weniger als 7 Tagen Restlaufzeit Sitzung und
+  // Cookie verlängern, statt bei jedem Request zu schreiben.
+  const msRemaining = session.expires_at.getTime() - Date.now();
+  if (msRemaining < REFRESH_THRESHOLD_MS) {
+    const newExpiry = new Date(Date.now() + SESSION_LIFETIME_MS);
+    await pool.query("update sessions set expires_at = $1, last_seen_at = now() where token_hash = $2", [
+      newExpiry,
+      tokenHash,
+    ]);
+    response.cookies.set(SESSION_COOKIE, token, {
+      httpOnly: true,
+      secure: (process.env.APP_URL ?? "").startsWith("https://"),
+      sameSite: "lax",
+      path: "/",
+      expires: newExpiry,
+    });
+  }
+
  return response;
 }

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// Legt beim allerersten Start (leere users-Tabelle) genau einen
+// Admin-Benutzer mit zufällig generiertem Passwort an und hängt die
+// Zugangsdaten an ZUGANGSDATEN.md an. Idempotent: bei bereits
+// vorhandenem Benutzer passiert nichts.
+//
+// Eigenständiges Skript statt Import aus lib/auth/password.ts, damit
+// dieses Vor-Build-Skript nicht an Next's Build-Output gekoppelt ist.
+// Die Hash-Logik ist bewusst identisch zur kanonischen Implementierung
+// in lib/auth/password.ts gehalten – Änderungen dort auch hier nachziehen.
+
+import { appendFileSync, existsSync } from "node:fs";
+import { randomBytes, scryptSync } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import pg from "pg";
+
+const N = 16384;
+const r = 8;
+const p = 1;
+const KEY_LEN = 64;
+const MAX_MEM = 32 * 1024 * 1024;
+
+function hashPassword(plain) {
+  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")}`;
+}
+
+function defaultAdminEmail() {
+  if (process.env.ADMIN_EMAIL) return process.env.ADMIN_EMAIL;
+  try {
+    const host = new URL(process.env.APP_URL ?? "http://localhost").hostname;
+    return `admin@${host}`;
+  } catch {
+    return "admin@localhost";
+  }
+}
+
+async function main() {
+  const client = new pg.Client({ connectionString: process.env.DATABASE_URL });
+  await client.connect();
+
+  try {
+    const { rows } = await client.query("select count(*)::int as count from users");
+    if (rows[0].count > 0) {
+      console.log("bootstrap-admin – Admin bereits vorhanden, überspringe.");
+      return;
+    }
+
+    const email = defaultAdminEmail();
+    const password = randomBytes(18).toString("base64url");
+    const passwordHash = hashPassword(password);
+
+    await client.query(
+      `insert into users (email, password_hash, full_name, role, password_auth_enabled)
+       values ($1, $2, '', 'admin', true)`,
+      [email, passwordHash]
+    );
+
+    // Der Admin-Datensatz steht ab hier in der Datenbank – das darf durch
+    // ein Problem beim Ablegen der Zugangsdaten nicht mehr verloren gehen
+    // (sonst gibt es einen Benutzer, dessen Passwort niemand kennt).
+    // appendFileSync() also bewusst nicht mehr ungefangen werfen lassen,
+    // sondern im Fehlerfall die Zugangsdaten direkt ins Log schreiben.
+    const zugangsdatenPath = join(
+      dirname(dirname(fileURLToPath(import.meta.url))),
+      "ZUGANGSDATEN.md"
+    );
+    const entry = `\n## Admin-Zugang (automatisch angelegt, ${new Date().toISOString().slice(0, 10)})\n\n- E-Mail: \`${email}\`\n- Passwort: \`${password}\`\n\nBitte nach dem ersten Login ändern.\n`;
+    let wroteFile = false;
+    try {
+      if (existsSync(zugangsdatenPath)) {
+        appendFileSync(zugangsdatenPath, entry);
+        wroteFile = true;
+      }
+    } catch (err) {
+      console.warn(`bootstrap-admin – Konnte ${zugangsdatenPath} nicht beschreiben: ${err.message}`);
+    }
+
+    if (wroteFile) {
+      console.log(`bootstrap-admin – Admin angelegt: ${email} (Passwort siehe ZUGANGSDATEN.md)`);
+    } else {
+      console.warn(
+        `bootstrap-admin – ${zugangsdatenPath} existiert nicht oder ist nicht beschreibbar. ` +
+          `Zugangsdaten NUR HIER im Log, bitte sofort notieren:`
+      );
+      console.log(`bootstrap-admin – Admin-E-Mail:   ${email}`);
+      console.log(`bootstrap-admin – Admin-Passwort: ${password}`);
+    }
+  } finally {
+    await client.end();
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
@@ -1,47 +0,0 @@
-// Konfiguriert die Passkey-Domain (WebAuthn Relying Party) des
-// Supabase-Projekts auf die öffentliche App-URL. Passkeys sind an die
-// Domain gebunden – nach einem Domain-Wechsel einmal ausführen.
-//
-// Aufruf:
-//   SUPABASE_ACCESS_TOKEN=... APP_URL=https://menu.example.de node scripts/configure-passkeys.mjs
-// oder mit der URL als Argument:
-//   SUPABASE_ACCESS_TOKEN=... node scripts/configure-passkeys.mjs https://menu.example.de
-
-const PROJECT_REF = "hvzikwjoyhoakedlywhj";
-const token = process.env.SUPABASE_ACCESS_TOKEN;
-const rawUrl = process.argv[2] ?? process.env.APP_URL;
-
-if (!token || !rawUrl) {
-  console.error(
-    "Nutzung: SUPABASE_ACCESS_TOKEN=... [APP_URL=https://…] node scripts/configure-passkeys.mjs [url]"
-  );
-  process.exit(1);
-}
-
-const url = new URL(rawUrl);
-const res = await fetch(
-  `https://api.supabase.com/v1/projects/${PROJECT_REF}/config/auth`,
-  {
-    method: "PATCH",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({
-      passkey_enabled: true,
-      webauthn_rp_id: url.hostname,
-      webauthn_rp_display_name: "Canteen Menu",
-      webauthn_rp_origins: url.origin,
-    }),
-  }
-);
-
-if (!res.ok) {
-  console.error(`Fehler ${res.status}: ${await res.text()}`);
-  process.exit(1);
-}
-
-console.log(`Passkey-Domain gesetzt: rp_id=${url.hostname}, origin=${url.origin}`);
-console.log(
-  "Hinweis: Bereits auf einer anderen Domain registrierte Passkeys verlieren ihre Gültigkeit."
-);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
florian.wilde	660490f1ac	Merge feature/v1.9.5: interner Bereich für Mobilgeräte nutzbar	2026-07-20 00:55:13 +02:00
florian.wildeandClaude Sonnet 5	0c69a21a85	feat: interner Bereich für Mobilgeräte nutzbar AppHeader.tsx: Hamburger-Menü unterhalb "sm" mit denselben Links gestapelt (Vorschläge-Badge-Logik in gemeinsame renderLinks()-Funktion ausgelagert), Panel schließt automatisch bei Navigation. Bisherige einzeilige Navigation bleibt ab "sm" unverändert. WeekEditor.tsx: Mobile Tag-für-Tag-Ansicht mit Tab-Leiste (Mo-Fr) statt der 6-spaltigen Tabelle, die bei 375px unbenutzbar gequetscht war. Zellinhalt (Eintragsliste + "hinzufügen"-Flow) in renderCell() extrahiert und von Tabelle und Karten-Ansicht gemeinsam genutzt, damit der Bearbeitungs-Zustand nicht dupliziert werden muss. Desktop-Tabelle unverändert ab "sm". DishManager/CodeListManager/UserManager/SectionManager/PasskeyManager: Kopf- und Listenzeilen brechen jetzt bei Bedarf um (flex-wrap) statt Buttons abzuschneiden, gleiches Muster wie bereits in SuggestionReview.tsx vorhanden. Version 1.9.5. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-20 00:54:05 +02:00
florian.wilde	db868d1174	Merge feature/v1.9: SSO-Login per OpenID Connect (Authentik u.a.)	2026-07-20 00:34:11 +02:00
florian.wildeandClaude Sonnet 5	32ef93ae8e	feat: SSO-Login per OpenID Connect (Authentik u.a.) Dritte Login-Methode neben Passwort und Passkey, konfiguriert über OIDC_ISSUER/OIDC_CLIENT_ID/OIDC_CLIENT_SECRET (optional, Button bleibt ohne diese Vars ausgeblendet). Authorization-Code-Flow mit PKCE, ID-Token-Signaturprüfung gegen das JWKS des Providers via neuer Abhängigkeit "jose" (RS256 fest gepinnt gegen Algorithm-Confusion), State/Nonce kurzlebig und einmalig verwendbar in neuer Tabelle oidc_states (Migration 0003, analog zu webauthn_challenges). Funktioniert ausschließlich für bereits angelegte Benutzer (Abgleich per E-Mail) – kein Auto-Provisioning, keine Rollenübernahme aus Claims, beides bleibt exklusiv über die bestehende Benutzerverwaltung steuerbar. app/login/page.tsx zu Server-Component-Wrapper reduziert (prüft isConfigured(), liest ?error= aus searchParams), bisheriger Inhalt nach components/LoginForm.tsx verschoben. Version 1.9.0. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-20 00:29:57 +02:00
florian.wilde	73cbda65a1	Merge feature/update-script: Update-Skript für Linux-Deployments (update.sh)	2026-07-20 00:08:18 +02:00
florian.wildeandClaude Sonnet 5	3b5fbd1bcd	feat: Update-Skript fuer Linux-Deployments (update.sh) Stoppt den Docker-Stack, sichert lokale Aenderungen an docker-compose.yml per git stash (falls vorhanden), fuehrt git pull aus, spielt die Aenderungen zurueck und startet den Stack neu im Build-Modus. Bricht bei git-pull- oder Stash-Konflikten kontrolliert ab statt mit einem halb aktualisierten Stand weiterzumachen. Version 1.8.1. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-20 00:05:56 +02:00
florian.wilde	f561ac29ba	Merge feature/v1.8: Umschaltbarer Hinweismodus für Allergene/Zusatzstoffe	2026-07-19 23:58:45 +02:00
florian.wildeandClaude Sonnet 5	de8914f9cc	feat: Umschaltbarer Hinweismodus für Allergene/Zusatzstoffe Neue Migration 0002_labeling_notice.sql: settings.labeling_mode ("detailed"/"notice") + labeling_notice(_en/_pl). Auf der Seite "Allergene & Zusatzstoffe" (LabelingNoticeEditor) kann zwischen der detaillierten Auswahl je Gericht und einem editierbaren Hinweistext umgeschaltet werden. Im Hinweismodus entfällt auf der öffentlichen Speisekarte (Desktop + Mobile) die Legende und die Kürzel an den Gerichten, in der Gerichte-Verwaltung wird die Chip-Auswahl beim Bearbeiten ausgeblendet. Umschalten/Bearbeiten ist für staff und admin freigegeben, Farben in /api/settings bleiben admin-only. Version 1.8.0. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-19 23:57:43 +02:00
florian.wilde	96eaf3989e	Merge feature/v1.7: CSV-Import/-Export, RSS-Fix für mehrere Essenszeiten	2026-07-19 23:14:02 +02:00
florian.wildeandClaude Sonnet 5	474467811c	feat: CSV-Import/-Export für Gerichte/Allergene/Zusatzstoffe, RSS-Fix für mehrere Essenszeiten CSV-Import/-Export (Gerichte, Allergene, Zusatzstoffe): neue Export-/ Import-Routen unter app/api//export und /import, hand-geschriebener CSV-Parser/-Serializer (lib/csv.ts, keine neue Abhängigkeit), Upsert über Kürzel (Allergene/Zusatzstoffe) bzw. exakten Namen (Gerichte, mit Ambiguitäts-Check bei Namensdopplung). UI-Buttons in DishManager und CodeListManager. RSS-Feed: <content:encoded> zusätzlich zu <description> ausgeben, da mehrere Feed-Reader description als kürzbare Vorschau behandeln und dadurch bei mehreren Essenszeiten pro Tag nur die erste zeigten. Version 1.7.0. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-19 23:10:36 +02:00
florian.wilde	5874eb31b6	Merge fix/branding-dir-env: BRANDING_DIR im app-Dienst setzen (Upload-500-Fix)	2026-07-18 15:11:27 +02:00
florian.wildeandClaude Sonnet 5	358872d56c	fix: BRANDING_DIR im app-Dienst setzen, sonst 500 beim Logo/Favicon-Upload Ohne die Variable weicht lib/branding.ts auf ${cwd}/data/branding (= /app/data/branding) aus statt das im Dockerfile vorbereitete und gemountete /data/branding zu nutzen. /app gehört root, der App-Prozess läuft aber als nicht-root – das Anlegen des Fallback-Verzeichnisses schlägt mit EACCES fehl. Version 1.6.3. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-18 15:10:46 +02:00
florian.wilde	36be08cea7	Merge fix/bootstrap-admin-file-permission: Admin-Passwort nicht mehr verlieren bei EACCES bootstrap-admin.mjs verliert das generierte Admin-Passwort nicht mehr, wenn ZUGANGSDATEN.md nicht beschreibbar ist (Fallback: Log statt Absturz nach erfolgreichem DB-Insert). DEPLOYMENT.md ergänzt um chmod 666 in Schritt 2 sowie Fehlerbehebung für ECONNREFUSED und diesen EACCES-Fall.	2026-07-18 14:51:55 +02:00
florian.wilde	b63822060d	Version 1.6.2	2026-07-18 14:51:29 +02:00
florian.wilde	94a2c98252	bootstrap-admin.mjs: Zugangsdaten nicht mehr verlieren, wenn ZUGANGSDATEN.md nicht beschreibbar ist Der Admin-Benutzer wird immer in der Datenbank angelegt, bevor versucht wird, die generierten Zugangsdaten in ZUGANGSDATEN.md zu schreiben. Schlug dieser Schreibvorgang fehl (z. B. EACCES, weil die per Bind-Mount eingebundene Host-Datei root gehört und der App-Container als nicht-root läuft), flog bisher eine ungefangene Exception – das Skript brach ab, BEVOR das Passwort irgendwo protokolliert wurde. Der Admin existierte dann in der DB, aber niemand kannte sein Passwort mehr. appendFileSync() läuft jetzt in einem try/catch; schlägt der Dateizugriff fehl, werden E-Mail und Passwort stattdessen direkt ins Log geschrieben, und das Skript beendet sich weiterhin mit Exitcode 0 (die eigentlich kritische Operation – der DB-Insert – ist ja bereits erfolgreich). Lokal verifiziert: Skript bricht bei einer nicht beschreibbaren ZUGANGSDATEN.md nicht mehr ab, Zugangsdaten landen im Log, zweiter Lauf bleibt idempotent. DEPLOYMENT.md: Schritt 2 ergänzt um "chmod 666 ZUGANGSDATEN.md" (der eigentliche Auslöser), neue Fehlerbehebung-Einträge für ECONNREFUSED-Startreihenfolge und diesen EACCES-Fall inkl. Recovery-Anleitung für einen bereits verwaisten Admin-Account.	2026-07-18 14:44:38 +02:00
florian.wilde	0d9d26b885	Merge fix/deployment-guide-pg-password: DB-Port nicht mehr exponiert, Deployment-Doku-Fixes Datenbank ist nur noch im internen Compose-Netzwerk erreichbar (kein Host-Port mehr). DEPLOYMENT.md: Fehlerbehebung für "password authentication failed" (PostgreSQL übernimmt das Passwort nur beim allerersten Start), .env.example warnt vor Sonderzeichen in LOCAL_PG_PASSWORD.	2026-07-18 14:30:00 +02:00
florian.wilde	233027fd17	Version 1.6.1	2026-07-18 14:29:13 +02:00
florian.wilde	469b93ee05	Datenbank-Port nicht mehr auf den Host exponieren docker-compose.yml: "ports: 5433:5432" beim db-Dienst entfernt. Die Datenbank ist damit nur noch innerhalb des Compose-Netzwerks unter "db:5432" erreichbar (für app/dev), nicht mehr vom Host oder von außen – reduziert die Angriffsfläche, ohne dass sich am App-Betrieb etwas ändert (Verbindung läuft ohnehin über den internen Service-Namen). Zugriff für Debugging/Backups weiterhin über "docker compose exec db psql"/"pg_dump" möglich. Lokal verifiziert: App verbindet sich weiterhin erfolgreich (Migration/ Bootstrap/Login laufen durch), Verbindungsversuch vom Host auf Port 5433 wird jetzt abgelehnt (connection refused). README.md an die entfallene Portangabe angepasst.	2026-07-18 14:25:55 +02:00
florian.wilde	536f51d516	DEPLOYMENT.md: Fehlerbehebung für "password authentication failed" Beim Ausrollen auf einem echten Server aufgetreten: PostgreSQL setzt sein Passwort nur beim allerersten Start auf leerem Datenverzeichnis – lief "docker compose up" vorher schon einmal ohne "--env-file .env.local" (oder wurde LOCAL_PG_PASSWORD nachträglich geändert), bleibt im Volume ein anderes Passwort stehen als die App danach verwendet. Neue Fehlerbehebung-Sektion mit der konkreten Fehlermeldung und zwei Fixes (Volume neu anlegen bei frischem Deployment, sonst Passwort im laufenden Container angleichen). Warnhinweis in Schritt 3 ergänzt. .env.example: Hinweis, dass LOCAL_PG_PASSWORD nur aus Buchstaben/ Zahlen bestehen sollte (#, $, Leerzeichen, Anführungszeichen können beim .env-Parsing zu stillen Fehlern führen).	2026-07-18 14:20:01 +02:00
florian.wilde	3b8f7de5e4	Merge feature/v1.6: RSS-Feed, Vorschläge-Badge, Deployment-Anleitung RSS-Feed des Speiseplans (/feed.xml, ein Eintrag pro Tag) mit Autodiscovery-Link und sichtbarem Icon im Header. Anzahl offener Rezeptvorschläge als Badge in der internen Navigation. Letzte Supabase-Erwähnungen aus aktiver Dokumentation entfernt. Neues DEPLOYMENT.md mit Schritt-für-Schritt-Anleitung für einen neuen Server.	2026-07-18 12:32:18 +02:00
florian.wilde	c986327c1c	Version 1.6.0 Verifiziert: RSS-Feed (/feed.xml, gültiges RSS 2.0, korrekte Tages- Einträge inkl. Essenszeiten/Preisen), Autodiscovery-Link + sichtbares Icon auf Desktop und Mobile, Vorschläge-Badge (Anzahl offener Rezeptvorschläge, aktualisiert bei Navigation), keine verbliebenen Supabase-Erwähnungen in aktiver Doku/Kommentaren.	2026-07-18 12:26:20 +02:00
florian.wilde	65bfd931cc	Schritt-für-Schritt-Deployment-Anleitung für neuen Server Neues DEPLOYMENT.md: Voraussetzungen, Repository holen, .env.local konfigurieren, docker compose up --build, Admin-Zugangsdaten aus ZUGANGSDATEN.md abholen, Reverse-Proxy/HTTPS (Caddy-Beispiel), Updates, Backup der Docker-Volumes. Aus README.md verlinkt. .env.example: LOCAL_PG_PASSWORD war bisher nirgends dokumentiert, obwohl docker-compose.yml die DATABASE_URL des App-Containers daraus zusammenbaut (die dortige DATABASE_URL-Zeile wird beim Docker-Compose-Betrieb ignoriert) – beim Schreiben der Anleitung aufgefallen und ergänzt. README.md: RSS-Feed und Vorschläge-Badge in der Funktionstabelle ergänzt.	2026-07-18 12:23:46 +02:00
florian.wilde	6f78762e27	Letzte Supabase-Erwähnungen aus aktiver Doku/Kommentaren entfernt README.md, db/migrations/0001_init.sql, lib/auth/webauthn-config.ts, lib/branding.ts nannten Supabase noch in Kommentaren, die erklären, was diese Stellen ersetzen. Umformuliert, ohne den alten Anbieter beim Namen zu nennen. CHANGELOG.md bleibt unverändert – die Erwähnungen dort sind historischer Bestand (u. a. der v1.5.0-Eintrag über die Supabase-Ablösung selbst) und sollen als Zeitdokument stehen bleiben.	2026-07-18 12:21:21 +02:00
florian.wilde	08a5ef8a2b	v1.6: RSS-Feed für den Speiseplan + Badge für offene Rezeptvorschläge app/feed.xml: RSS-2.0-Feed mit einem Eintrag pro Tag (aktuelle + nächste Woche), Gerichte je Essenszeit im CDATA-Beschreibungstext. Immer auf Deutsch, da Feedreader kein Sprach-Cookie mitschicken. Autodiscovery-Link im <head> (app/layout.tsx) sowie sichtbares RSS-Icon im Header der öffentlichen Speisekarte (neben Sprachumschalter/ Anmelden – die einzige Stelle, die auf allen Bildschirmgrößen sichtbar ist). AppHeader: "Vorschläge"-Navigationspunkt zeigt jetzt die Anzahl offener Rezeptvorschläge als Zahl im roten Kreis (GET /api/dish-suggestions, bereits staff/admin-beschränkt), aktualisiert sich bei Navigation innerhalb des internen Bereichs.	2026-07-18 12:18:46 +02:00
florian.wilde	b7c24364b8	Merge feature/v1.5: Supabase entfernt, vollständig selbst gehostet Postgres statt Supabase-Cloud, eigene Session-/Passkey-Auth, lokale Branding-Dateiablage, Autorisierung in den API-Routen statt RLS, automatischer Admin-Bootstrap bei leerer Datenbank, Gerichtsuche im Wochenplan. Vor dem Merge per Sicherheitsprüfung geprüft, ein gefundenes SVG-Upload-XSS-Problem behoben.	2026-07-18 11:59:13 +02:00
florian.wilde	be80edec61	Changelog: Hinweis auf noch offenen Merge entfernt, v1.5.0 finalisiert	2026-07-18 11:58:50 +02:00
florian.wilde	0958abaac6	Sicherheit: SVG-Upload für Logo/Favicon nicht mehr erlaubt Der Branding-Upload akzeptierte bisher jeden Dateityp, der clientseitig mit "image/" beginnt, inkl. SVG. Anders als beim vorherigen Supabase- Storage-Bucket (andere Origin) wird die Datei jetzt auf der eigenen Origin unter /branding/[filename] ausgeliefert – eine SVG mit eingebettetem <script> hätte bei direktem Aufruf der Datei-URL (z. B. "Bild in neuem Tab öffnen") mit dem Session-Cookie eines anderen Admins ausgeführt werden können und wäre dabei auch am CSRF-Schutz vorbeigekommen (Origin stimmt ja). Upload-Route erlaubt jetzt nur noch eine Whitelist an Rasterformaten (png/jpg/webp/gif/ico), die Dateiendung wird aus dem geprüften MIME-Typ abgeleitet statt aus dem vom Client gesendeten Dateinamen. Die Ausliefer-Route kennt "svg" als Content-Type nicht mehr (Defense in Depth). Gefunden bei der Sicherheitsprüfung vor dem Merge nach master.	2026-07-18 11:58:07 +02:00
florian.wilde	3d13ba88f4	Wochenplan: Gerichtsuche statt langer Dropdown-Liste, Beispieldaten zurück WeekEditor: "Mahlzeit hinzufügen" zeigt jetzt ein Suchfeld mit gefilterter Trefferliste (wie die Live-Suche bei Gerichten) statt einer langen Dropdown-Liste zum Durchscrollen. Ausgewähltes Gericht lässt sich per ×-Button wieder ändern. Neues Skript db/seed-demo.sql (+ db/seed-demo.mjs, "npm run db:seed-demo"): spielt den ursprünglichen Beispieldatensatz ein (4 Essenszeiten, 14 Allergene, 11 Zusatzstoffe, 18 Testgerichte, zwei Beispielwochen) – nur für lokale Entwicklung/Demos, kein Teil der automatischen Migrationen, da frische Deployments weiterhin leer starten sollen.	2026-07-18 11:35:13 +02:00
florian.wilde	c60f481aec	Version 1.5.0 Vollständig verifiziert: natives npm run dev auf frisch geleerter lokaler Postgres-DB (Migration + Admin-Bootstrap + ZUGANGSDATEN.md, Login, Essenszeiten/Gerichte/Wochenplan/Kennzeichnung/Vorschläge-CRUD, Konto-Verwaltung inkl. serverseitiger Passkey-Absicherung, Branding-Upload/-Löschung, Admin-Benutzerverwaltung mit rollenbasierter Zugriffskontrolle, Neustart-Idempotenz) sowie über docker compose --build auf eigenem Volume (Migration/Bootstrap im Container-Entrypoint, Bind-Mount für ZUGANGSDATEN.md, Login).	2026-07-18 11:21:19 +02:00
florian.wilde	b512093a7e	v1.5: Docker/Compose/.env.example auf selbst gehostetes Postgres umgestellt Dockerfile: keine NEXT_PUBLIC_*-Build-Args mehr (Branding-URLs sind jetzt relativ, kein Anon-Key-Konzept mehr – das Image wird dadurch umgebungsunabhängig), db/migrate.mjs + scripts/ werden zusätzlich in die Runner-Stage kopiert (nicht Teil von Next's Standalone-Trace), CMD wendet Migrationen an und legt bei Bedarf den Admin an, bevor der Server startet. docker-compose.yml: db-Dienst ist jetzt die primäre Datenbank (kein Supabase-Dump-Mount mehr), neues Volume branding_data für Logo/Favicon, Bind-Mount für ZUGANGSDATEN.md. .env.example: Supabase-Variablen durch DATABASE_URL + optionales ADMIN_EMAIL ersetzt. package.json: @supabase/ssr und @supabase/supabase-js entfernt. README.md komplett auf die neue Architektur aktualisiert.	2026-07-18 11:02:16 +02:00
florian.wilde	a9a9cf7ba4	v1.5: Alle Manager-Komponenten auf eigene API-Routen umgestellt Neue interne Route Handler unter app/api/ (dishes inkl. Bulk-Delete, sections, allergens, additives, menu-entries, dish-suggestions, settings, admin/branding) ersetzen den direkten Browser→Postgrest- Zugriff der bisherigen Supabase-Anbindung. Jede Route prüft Autorisierung selbst (lib/auth/session.ts requireRole) statt sich auf Postgres-RLS zu verlassen – ersetzt 1:1 die bisherigen Policies (öffentlich lesbar / staff+admin schreiben / nur admin für Einstellungen & Benutzer). Rezeptvorschlag-Dublettencheck (SuggestionForm) läuft jetzt zwingend serverseitig im POST-Handler, da es keinen Browser→Postgres-Pfad mehr gibt. "Passkey annehmen" (SuggestionReview) läuft transaktional (Gericht anlegen + Vorschlag löschen in einem Schritt). Logo/Favicon: neuer lokaler Dateispeicher (lib/branding.ts, Docker- Volume) statt Supabase-Storage-Bucket, ausgeliefert über app/branding/[filename]. logoUrl()/faviconUrl() liefern jetzt einfache relative Pfade statt einer fest verdrahteten Supabase-Storage-URL. DeepL-Route (api/translate) und Benutzerverwaltung (api/admin/users) laufen jetzt gegen die users-Tabelle statt Supabase Auth. Alle "use client"-Manager-Komponenten (DishManager, WeekEditor, SectionManager, CodeListManager, SuggestionForm/Review, UserManager, DesignEditor) rufen ihre jeweiligen /api/-Routen per fetch() statt den Supabase-Browser-Client zu nutzen.	2026-07-18 11:01:52 +02:00
florian.wilde	28c9ec15c8	v1.5: Selbst gehostete Auth (Passwort + Passkeys), Postgres statt Supabase Fundament: db/migrations/0001_init.sql (users/sessions/passkey_credentials/ webauthn_challenges + Inhaltstabellen ohne RLS), db/migrate.mjs (idempotenter Migrationsrunner), lib/db (pg-Pool + query-Wrapper), lib/auth/password.ts (Node-crypto.scrypt, keine neue Abhängigkeit), lib/auth/session.ts (opake DB-Session-Tokens, Sliding-Refresh in proxy.ts). Passkeys: @simplewebauthn/server + /browser ersetzen Supabase's experimentelles WebAuthn-API (dafür gab es bisher kein eigenes Credential-Schema); RP-Konfiguration kommt jetzt direkt aus APP_URL statt über scripts/configure-passkeys.mjs und die Supabase-Management-API. scripts/bootstrap-admin.mjs legt bei leerer users-Tabelle automatisch einen Admin mit zufälligem Passwort an und hängt die Zugangsdaten an ZUGANGSDATEN.md an (idempotent, via predev/prestart-Hooks aufgerufen). Bugfix im Zuge des Umbaus: "mind. 1 Passkey nötig, um Passwort-Login zu deaktivieren" wurde bisher nur clientseitig geprüft – jetzt zusätzlich serverseitig in PATCH /api/account. E-Mail-Änderung im eigenen Konto läuft jetzt direkt nach Passwort-Bestätigung statt über eine Supabase-Bestätigungsmail (kein SMTP-Server vorhanden). Rest der Anwendung (Gerichte/Essenszeiten/Kennzeichnung/Vorschläge/ Benutzerverwaltung/Branding) nutzt noch den alten Supabase-Client – folgt in weiteren Commits.	2026-07-18 10:42:21 +02:00