CHANGELOG.md

@@ -2,38 +2,6 @@
 
 All notable changes to this project are documented in this file.
 
-## [1.121.2] - 2026-09-12
-
-### Changed
-- Die Spaltenaufteilung sich überlappender Termine im Tagesraster ist aus
-  `WeeklyView.tsx` in `src/lib/weekly/event-layout.ts` ausgelagert
-  (`layoutDaySegments`/`computeEventOverlapLayout`), mit eigenen Tests
-  abgesichert. Erster Schnitt der CodeScene-getriebenen Sanierung; der
-  Algorithmus selbst ist unverändert, kein sichtbares Verhalten geändert.
-
-## [1.121.1] - 2026-09-12
-
-### Fixed
-- **`/api/calendar/apple/sync` war ohne Anmeldung erreichbar** und hat beliebige
-  Apple-Zugangsdaten aus dem Request gegen Apple CalDAV geschickt. Die Instanz
-  liess sich damit als Relay zum Durchprobieren fremder Zugangsdaten
-  missbrauchen. Die Route verlangt jetzt dieselbe Session-Prüfung wie
-  `/api/calendar/apple/connect`.
-- `AuthForm.tsx` schrieb E-Mail-Adresse und Passwort im Klartext in die
-  Browser-Konsole. Die Debug-Ausgaben sind entfernt.
-
-## [1.121.0] - 2026-09-12
-
-### Fixed
-- **Termine über Mitternacht verlängerten den Starttag**, statt am Folgetag
-  weiterzulaufen. Ein Termin von 22:00 bis 02:00 erschien bisher als ein
-  überlanger Block im Starttag; jetzt wird er an der Tagesgrenze geteilt:
-  22:00–24:00 am Starttag, 00:00–02:00 am Folgetag — so, wie es Kalender-Apps
-  zeigen. Die Aufteilungsregel (`splitEventByDay` in
-  `src/lib/weekly/date-utils.ts`) ist mit Unit-Tests abgesichert. Klick, Drag
-  und Resize wirken weiterhin auf den ungeteilten Termin; Payloads und API
-  sind unverändert.
-
 ## [1.120.1] - 2026-09-07
 
 ### Fixed

TODO.md

@@ -0,0 +1,431 @@
+# To-do — Repository-Audit vom 2026-09-06
+
+Abarbeitungsliste aus dem Repository-Audit. Reihenfolge ist bewusst gewählt:
+schnelle Sicherheitsgewinne zuerst, das große Refactoring zuletzt.
+
+Abhaken mit `[x]`. Die Nummern in Klammern entsprechen den Punkten aus dem Audit.
+
+---
+
+## Block A — Schnell erledigt, sofortiger Gewinn
+
+### A1. Tote Mock-Login-Route entfernen (Audit 3)
+- [x] `src/app/api/auth/login/route.ts` löschen
+- [x] Prüfen, dass niemand sie aufruft (`grep -rn "api/auth/login" src/`)
+- [ ] Commit + Version bumpen
+
+**Warum:** Altcode aus der Anfangszeit. Vergleicht gegen ein hartcodiertes Fake-Passwort
+(`$2b$10$examplehashedpassword`), erzeugt ein bedeutungsloses `mock-jwt-token-…` und setzt es
+als Cookie. Weil die Middleware `/api/auth/*` bewusst durchlässt, ist die Route **ohne Login
+von außen erreichbar** und schreibt jede probierte E-Mail per `console.log` ins Log.
+Kein Login-Bypass (der Vergleich schlägt immer fehl), aber unnötige Angriffsfläche.
+
+### A2. `npm test` reparieren (Audit 6)
+- [x] Entscheiden: Jest raus oder Jest einrichten
+- [x] `package.json`: `"test"` auf das zeigen lassen, was wirklich existiert
+- [x] `"test:e2e"` für Playwright ergänzen
+- [x] Debug-Skripte in `tests/` aussortieren
+- [x] **63 Unit-Tests** für die ausgelagerten reinen Funktionen (`tests/unit/`), laufen in
+      ~170 ms ohne Browser und ohne Datenbank über Nodes eingebauten Test-Runner
+- [ ] E2E-Tests mit echtem Login schreiben (braucht laufende App + Datenbank)
+- [ ] Testlauf in den nächtlichen Qualitätslauf aufnehmen (`scripts/quality-check.sh`)
+
+**Warum:** `"test": "jest"` — aber es gibt **keine Jest-Config und keinen einzigen Jest-Test**.
+Die 15 Dateien in `tests/` sind Playwright-Specs, und die Namen verraten den Charakter:
+`login-debug.spec.ts`, `css-debug-test.spec.ts`, `login-simple-debug.spec.ts`. Wegwerf-Skripte,
+keine Regressionstests. `npm test` läuft ins Leere.
+
+**Aufräumen:** Die reinen Debug-Skripte löschen, die brauchbaren behalten und benennen.
+
+### A3. `dev`-Branch auflösen (Audit 5)
+- [ ] Die vier Maßnahmen aus `f6c4a21` frisch auf `main` anwenden (siehe A1, B1, B2)
+- [ ] `dev` auf `main` zurücksetzen **oder** löschen
+- [ ] `CLAUDE.md`: Branch-Strategie an die gelebte Praxis anpassen
+
+**Warum:** Commit `f6c4a21` vom 04.07.2026 behebt bereits Rate-Limiting, Token-Hashing,
+die Mock-Route und die Secret-Datei — wurde aber nie gemerged. `dev` fehlen inzwischen
+**70 Commits** von `main`, ein Merge würde alte Dateistände zurückholen. Deshalb:
+Commit als *Vorlage* nehmen, Änderungen neu anwenden, `dev` danach entsorgen.
+
+`CLAUDE.md` beschreibt einen `dev` → `main`-Workflow, der faktisch nicht gelebt wird
+(alles läuft direkt auf `main`). Doku an die Realität anpassen ist ehrlicher.
+
+---
+
+## Block B — Sicherheit
+
+### B1. Rate-Limiting auf den Auth-Endpunkten (Audit 4)
+- [x] Sliding-Window-Limiter in `src/lib/rate-limit.ts` anlegen
+- [x] Einbinden in `signup`
+- [x] Einbinden in `resend-verification`
+- [x] Einbinden in `reset-password`
+- [x] Einbinden in `verify-email`
+- [x] Limits dokumentieren (Vorschlag: 5 Versuche / 15 Minuten je IP)
+
+**Warum:** Im gesamten `src/` ist **kein Limiter** vorhanden. Signup, Passwort-Reset und
+Verification-Mails sind unbegrenzt aufrufbar — Einladung zum Missbrauch deines SMTP-Zugangs.
+
+### B2. Passwort-Reset-Token nur als SHA-256-Hash speichern (Audit 4)
+- [x] Beim Erzeugen: Klartext per Mail, **Hash** in die DB
+- [x] Beim Einlösen: eingehenden Token hashen, dann vergleichen
+- [ ] Migration für bestehende Tokens (einfachster Weg: alle invalidieren)
+
+**Warum:** `src/app/api/auth/reset-password/route.ts:28` legt `passwordResetToken` im
+**Klartext** ab. Wer Lesezugriff auf die Datenbank hat, kann fremde Konten übernehmen.
+Der Token selbst kommt aus `crypto.randomUUID()` — das ist in Ordnung, nur die Ablage nicht.
+
+### B3. Secrets aus dem Git entfernen und rotieren (Audit 2)
+- [x] `.env.production.save` und `.env.local` gelöscht (mit `shred` überschrieben)
+- [x] `.gitignore` auf `.env*` erweitert (Ausnahme `.env.example`)
+- [x] `NEXTAUTH_SECRET` neu erzeugt — 44 Zeichen, geprüft
+- [x] `SMTP_PASSWORD` neu gesetzt
+- [x] `deployment-notes.md` und `INFRASTRUCTURE_REQUIREMENTS.md` aus dem Index entfernt
+- [x] Klartext-Werte in beiden Dateien durch Platzhalter ersetzt
+- [x] Passwort aus `tests/debug/db-connection-test.spec.ts` entfernt
+- [x] Nach dem Wechsel neu eingeloggt
+- [ ] Entscheiden: Historie umschreiben oder belassen (Empfehlung: belassen)
+- [ ] Prüfen, ob eines der geleakten DB-Passwörter noch aktiv ist (siehe F1)
+
+**Warum:** `.env.production.save` ist eingecheckt und enthält **echte Werte** —
+`DATABASE_URL` (70 Zeichen), `NEXTAUTH_SECRET` (20 Zeichen), `SMTP_PASSWORD` (20 Zeichen).
+`.gitignore` listet `.env.production`, die `.save`-Endung fällt durchs Raster.
+Drin seit Commit `da8d019`.
+
+**Entwarnung:** Das GitHub-Repo ist **privat** — nicht öffentlich abgreifbar. Die Werte
+stehen aber in der kompletten Historie, in jedem Klon und auf Gitea.
+
+Anleitung siehe [`docs/secret-rotation.md`](docs/secret-rotation.md).
+
+---
+
+## Block C — Build und Typsicherheit
+
+### C1. Build darf Fehler nicht mehr verschlucken (Audit 1)
+- [x] **Schritt 1:** `eslint.ignoreDuringBuilds` in `next.config.js` auf `false`
+- [x] Gemeldete ESLint-Fehler abarbeiten — es waren nur **2** (`prefer-const` in
+      `SettingsSidebar.tsx`), verifiziert: `next lint` endet jetzt mit Exit 0
+- [x] **Schritt 2:** `npm run type-check` — es waren **7 Fehler**, alle behoben
+- [x] **Schritt 3:** `typescript.ignoreBuildErrors` auf `false` — Build prüft jetzt Typen
+- [x] `tsconfig.json`: `include` von `**/*` auf `src/**/*` eingegrenzt. **Das war die
+      Ursache der Langsamkeit**, nicht die Dateigröße: Der Lauf dauert jetzt **19 Sekunden**
+      statt über 30 Minuten. Meine gegenteilige Vermutung war falsch.
+- [x] **3 Dateien mit `@ts-nocheck`** entschärft — im Projekt gibt es jetzt **kein einziges
+      `@ts-nocheck` mehr**. `calendar-cache.ts` brauchte es gar nicht (0 Fehler), in
+      `microsoft-todo.ts` fehlten Typannotationen, und in `outlook-calendar.ts` steckte
+      ein möglicher Laufzeitfehler dahinter.
+- [ ] `any`-Stellen reduzieren — ESLint zählt **470** `no-explicit-any` — fortlaufend, kein Blocker
+- [ ] **209** ungenutzte Variablen (`no-unused-vars`) aufräumen — fortlaufend
+- [ ] **11** unvollständige Hook-Abhängigkeiten (`react-hooks/exhaustive-deps`) prüfen —
+      die sind die gefährlichsten der Warnungen, weil daraus echte Bugs entstehen
+
+**Warum:** `next.config.js` hat `ignoreDuringBuilds: true` **und** `ignoreBuildErrors: true`.
+`tsconfig.json` sagt zwar `strict: true`, das ist aber wirkungslos, weil der Build die Fehler
+gar nicht meldet. **Ein Typfehler fällt nicht beim Bauen auf, sondern erst als kaputte Seite
+im Browser.** Ein erfolgreicher Build ist derzeit *kein* Beweis, dass der Code korrekt ist.
+
+**Achtung Reihenfolge:** Erst ESLint, dann TypeScript. Beides gleichzeitig abzuschalten
+blockiert jeden Deploy, bis alles behoben ist.
+
+---
+
+## Block D — Struktur
+
+### D1. Dateien über 4000 Zeilen aufteilen (Audit 7)
+
+Betroffen sind genau zwei Dateien:
+
+| Datei | Zeilen |
+|---|---:|
+| `src/components/WeeklyView.tsx` | **9.711** *(war 11.906)* |
+| `src/components/SettingsSidebar.tsx` | 5.445 |
+
+**Voraussetzung:** C1 muss laufen — ohne Typecheck ist ein Refactoring dieser Größe
+Blindflug. Ebenso hilfreich: A2, damit es überhaupt Tests gibt.
+
+#### WeeklyView.tsx → Zielstruktur
+- [x] Typen nach `src/lib/weekly/types.ts` (7 Typen, 97 Zeilen) — Build verifiziert
+- [x] `src/components/weekly/` angelegt
+- [x] **Entdeckung:** In `WeeklyView.tsx` steckten **acht eigenständige Komponenten**, die
+      gar nichts mit der Wochenansicht zu tun haben — zusammen rund 1.870 Zeilen. Drei davon
+      sind heraus: `ProjectIcon`, `ProjectsSidebar`, `NotesSidebar`.
+- [x] Restliche fünf herausgelöst: `TaskInput`, `SomedayAddTask`, `TaskItem`,
+      `ListVisualsPopover`, `TabVisualsPopover` — dazu die Prioritäts-Abzeichen, die
+      `GridTaskBlock` von `WeeklyView` importierte
+- [ ] Someday-Listen aus dem Haupt-JSX herauslösen (jetzt echtes Props-Design nötig)
+- [ ] All-Day-Leiste herauslösen
+- [ ] Zeitraster und Tagesspalten herauslösen
+- [ ] Einstellungs-Flyouts herauslösen
+- [ ] Drag & Drop in einen Hook (~15 Abhängigkeiten — erst sinnvoll, wenn der State
+      geordneter ist; ein Hook mit 15 Parametern wäre keine Verbesserung)
+- [x] Datums-/Zeitraster-Helfer nach `src/lib/weekly/date-utils.ts` (13 Funktionen, 202 Zeilen)
+- [x] Cookie-/Geräteeinstellungen nach `src/lib/weekly/device-settings.ts`
+- [x] Formatierungs-Helfer nach `src/lib/weekly/format.ts`
+- [ ] `getWeekNumber` existiert **dreimal** im Projekt (WeeklyView, `WeekPrintModal.tsx`,
+      `api/user/export-week-view/route.ts`) — Duplikate gegen `date-utils.ts` ersetzen,
+      vorher die drei Implementierungen auf Gleichheit prüfen
+- [ ] `calendar-cache.ts` hat mit `getWeekStart` eine **vierte** eigene Wochenlogik —
+      ebenfalls gegen `date-utils.ts` ersetzen
+- [ ] Daten-Laden in `useWeeklyData.ts`
+- [ ] `WeeklyView.tsx` bleibt als Orchestrator übrig
+
+#### SettingsSidebar.tsx → Zielstruktur
+- [ ] `src/components/settings/` anlegen
+- [ ] Ein Panel pro Themenbereich als eigene Datei
+- [ ] Gemeinsame Bausteine (Farbwähler, Schalterzeile) in `settings/controls/`
+
+**Vorgehen:** In kleinen Schritten, jeder Schritt ein eigener Commit, nach jedem Schritt
+`npm run build`. Kein "großer Wurf" — die Datei ist zu zentral.
+
+**Zwischenstand nach drei Schnitten:** 11.906 → 11.556 Zeilen, also **rund 3 %**. Damit sind
+die reinen Funktionen ohne Komponenten-State weitgehend heraus — das war der leichte Teil.
+
+Die verbleibenden ~11.500 Zeilen sind die Komponente selbst: JSX und Event-Handler, die auf
+gemeinsamen State zugreifen. Jeder weitere Schnitt braucht echtes Props-Design statt
+Verschieben. Realistisch pro Schnitt ein eigener Durchgang, und **erst mit Tests (A2) oder
+zumindest laufendem Typecheck sinnvoll** — ein Fehler beim Herauslösen von Drag & Drop fällt
+sonst wieder erst im Browser auf.
+
+**Warum:** `WeeklyView.tsx` ist ein Viertel des gesamten Quellcodes. Der Weekday-Bug von
+Anfang September saß genau dort und war nur deshalb schwer zu finden.
+
+---
+
+## Block E — Dauerhafte Absicherung
+
+### E1. Regelmäßige automatische Prüfung (Audit 8)
+- [x] SonarQube-Analyse gegen https://sq.martin-bierschenk.de einrichten
+- [x] Regelmäßigen Lauf aufsetzen — nightly 03:00, `todo-sonar.timer` (systemd user unit)
+- [x] `npm audit` in denselben Lauf aufnehmen (`scripts/quality-check.sh`)
+- [ ] `todo-sonar.timer` auf `scripts/quality-check.sh` umstellen statt nur `todo-sonar-scan`
+- [ ] Playwright-Tests in den nächtlichen Lauf aufnehmen (braucht laufende App — erst nach A2)
+- [ ] Quality Gate im SonarQube definieren
+- [ ] Ergebnis irgendwohin melden, wo es auffällt (bisher nur Konsolenausgabe)
+- [ ] **Entscheiden:** `.github/workflows/sonarqube.yml` löschen oder behalten
+
+**Stand:** Die Analyse läuft bereits — nächtlich um 03:00 auf dem Spark, per systemd-Timer,
+Ergebnis auf https://sq.martin-bierschenk.de. Was fehlte, war `npm audit` (Sicherheitslücken
+in Abhängigkeiten findet SonarQube nicht) und ein Bündel-Skript. Beides ist jetzt da.
+
+**Zur Entscheidung:** GitHub Actions wurde am 02.09. bewusst verworfen — das Repo ist privat,
+Actions-Minuten kosten, und der SonarQube-Server läuft ohnehin selbst gehostet. Trotzdem liegt
+seit dem 03.09. ein Workflow im Repo, der bei jedem Push auf `main` anspringt. Er ruft
+`npm run type-check` und `npm run lint` auf — beides schlägt derzeit fehl (siehe C1), der
+Workflow wäre also dauerhaft rot. Sein Projekt-Key war zudem falsch und hätte in ein zweites,
+leeres SonarQube-Projekt geschrieben; das ist korrigiert. Entweder löschen (passt zur
+Entscheidung vom 02.09.) oder bewusst behalten und C1 vorziehen.
+
+**Warum:** Bisher fallen Regressionen erst in Produktion auf. In Kombination mit C1
+(Build meldet Fehler) und A2 (Tests laufen) entsteht daraus ein echtes Netz.
+
+### E2. Abhängigkeiten auf Sicherheitslücken prüfen
+- [ ] `npm audit` auf dem Container ausführen
+- [ ] Kritische Funde beheben
+
+**Warum:** Konnte im Audit **nicht** geprüft werden — `node_modules` ist auf dem
+CIFS-Share nicht installierbar (keine Symlinks). Zu bekannten Lücken in den
+Abhängigkeiten liegt daher **keine Aussage** vor. Muss nachgeholt werden.
+
+---
+
+## Block F — Zurückgestellt
+
+### F1. Datenbank-Passwort rotieren *(bewusst nach hinten geschoben)*
+- [ ] Prüfen, ob eines der geleakten Passwörter noch aktiv ist
+- [ ] Falls ja: rotieren nach [`docs/secret-rotation.md`](docs/secret-rotation.md), Schritt 2
+- [ ] Falls nein: nichts zu tun, Haken dran
+
+**Warum zurückgestellt:** Von den drei Zugangsdaten ist dieses das am wenigsten dringende.
+Die Datenbank hört auf einer **privaten LAN-Adresse**, nicht am Internet. Wer das Passwort
+aus dem Git holen will, braucht Zugriff auf das **private** Repository — und ist damit
+ohnehin schon im Netz. `NEXTAUTH_SECRET` und `SMTP_PASSWORD` waren die kritischen, beide
+sind erledigt.
+
+**Und es ist riskant:** Supabase läuft selbst gehostet per Docker. Dasselbe Passwort steckt
+in `supabase/docker/.env` **und** in Postgres. Ein halb durchgeführter Wechsel legt die
+Datenbank und damit die App lahm. Das gehört an einen ruhigen Abend, nicht nebenbei.
+
+**Zwei verschiedene Passwörter liegen im Git** (Fingerabdrücke, keine Klartexte):
+
+| Fingerabdruck | Wo | Stand |
+|---|---|---|
+| `59fb583eaae9` | ehem. `deployment-notes.md`, `INFRASTRUCTURE_REQUIREMENTS.md` | altes Docker-Compose-Setup (`@db:5432`); Dateien bereinigt |
+| `9dbb40b14c4d` | ehem. `.env.production.save` | Supabase-Zugang, **Status offen** — Datei gelöscht, Wert steht noch in der Historie |
+
+Vom Nutzer bestätigt: das alte `NEXTAUTH_SECRET` (20 Zeichen) und das alte `SMTP_PASSWORD`
+sind **nicht mehr in Verwendung**, beide wurden rotiert. Offen ist allein das
+Datenbank-Passwort.
+
+Prüfen lässt sich das auf dem Container, ohne einen Wert auszugeben:
+
+```bash
+cd /root/My-Weekly-ToDo-List
+grep '^DATABASE_URL=' .env | sed -E 's|.*://[^:]+:([^@]+)@.*|\1|' | tr -d '\n' | sha256sum | cut -c1-12
+```
+
+Ergibt der Befehl `9dbb40b14c4d`, ist das geleakte Passwort noch in Benutzung — dann lohnt
+F1. Kommt etwas anderes heraus, wurde es längst getauscht und du kannst F1 abhaken.
+
+---
+
+## Block H — Aus dem scharfen Typecheck
+
+### H1. Notion-Anbindung war defekt *(migriert, aber ungetestet)*
+- [ ] Migration praktisch prüfen (braucht Notion-Zugang)
+- [ ] Betroffene Nutzer informieren: Notion-Verbindung muss neu eingerichtet werden
+
+**Warum:** Der Code rief `notion.databases.query()` auf. Die Methode gibt es in
+`@notionhq/client` v5 nicht mehr (nur noch retrieve/create/update) — der Aufruf lief zur
+Laufzeit in ein "is not a function". **Die Notion-Anbindung war damit schlicht kaputt**, und
+das ist niemandem aufgefallen, weil der Build Typfehler verschluckte.
+
+Umgestellt auf `dataSources.query()`; die Suche filtert jetzt auf `data_source` statt
+`database`. Das ist in sich konsistent, aber **mangels Notion-Zugang nicht erprobt**.
+
+⚠️ **Gespeicherte Verbindungen enthalten alte `database_id`s. Das sind keine
+`data_source_id`s** — betroffene Nutzer müssen Notion einmal neu verbinden.
+
+---
+
+## Block K — Deploy-Sicherheit ✅
+
+### K1. Build zerstört nicht mehr die laufende App ✅ *(v1.120.0)*
+- [x] Build läuft nach `.next-build`, das laufende `.next` bleibt unberührt
+- [x] Smoke-Test vor dem Umschalten — der neue Build muss einmal geantwortet haben
+- [x] Umschalten erst danach, alter Stand bleibt als `.next-previous` liegen
+- [x] Beide Fälle getestet: Fehlschlag lässt `.next` unangetastet, Erfolg schaltet sauber um
+- [x] Build-Erkennung an den gebauten Commit gekoppelt (`.next/BUILD_COMMIT`) statt an
+      `HEAD` vs. `origin/main` — sonst überspringt das Skript den Build, wenn jemand vorher
+      von Hand `git pull` ausführt
+- [x] Smoke-Test-Server wird zuverlässig beendet (`exec`, sonst überlebt `node` als Waise
+      und blockiert Port 3999 für alle weiteren Deploys)
+
+**Warum:** `next build` lief direkt auf `.next` — also auf dem Verzeichnis, aus dem die
+laufende App bedient wird. Scheiterte der Build, war nicht nur das Update weg, sondern die
+laufende Instanz gleich mit: PM2 fand `server.js` nicht mehr
+(`MODULE_NOT_FOUND`) und geriet in eine Neustartschleife mit über 790 Versuchen.
+Am 07.09. war die Seite dadurch rund eine Stunde unbrauchbar.
+
+**Zurückrollen** (falls ein Deploy doch mal Mist ausliefert):
+
+```bash
+pm2 stop my-weekly-todo
+cd /root/My-Weekly-ToDo-List
+rm -rf .next && mv .next-previous .next
+pm2 restart my-weekly-todo
+```
+
+---
+
+## Block J — Build-Speicher auf dem Container
+
+### J1. Container-RAM erhöhen *(empfohlen)*
+- [ ] LXC 202 von 3 GB auf 6 GB anheben (Proxmox → Container → Resources → Memory)
+
+**Warum:** `next build` braucht **rund 2,6 GB Spitzenspeicher** (gemessen). Bei 3 GB
+Container-RAM bleibt fast nichts übrig — der laufende PM2-Prozess und das System teilen
+sich den Rest. Der Deploy vom 07.09. starb deshalb mit
+`FATAL ERROR: Ineffective mark-compacts near heap limit`.
+
+`scripts/update-app.sh` setzt jetzt `NODE_OPTIONS="--max-old-space-size=2048"`, weil Nodes
+Standard-Heap auf diesem Container bei nur rund 1,5 GB liegt. Das ist die Sofortmaßnahme,
+aber bei 2,6 GB Bedarf bleibt es knapp. **Mehr RAM ist die eigentliche Lösung** und in
+Proxmox ein Klick.
+
+**Nicht die Ursache — geprüft:** ESLint im Build. Gemessener Spitzenspeicher mit ESLint
+2.590 MB, ohne 2.595 MB. Kein Unterschied.
+
+### J2. Alternative: woanders bauen
+- [ ] Erwägen, den Build auf dem Spark laufen zu lassen und nur `.next/standalone` zu
+      übertragen
+
+**Warum:** Dann braucht der Produktionscontainer überhaupt keinen Build-Speicher mehr —
+er würde nur noch fertige Dateien erhalten und PM2 neu starten. Grösserer Umbau des
+Deploy-Wegs, aber die sauberste Trennung.
+
+---
+
+## Block I — UI-Wünsche
+
+### I1. Aktuellen Tag auch im Spaltenkopf hervorheben ✅ *(vom Nutzer bestätigt)*
+- [x] Hervorhebungsfarbe zusätzlich hinter Wochentagsname und Datum gelegt
+
+**Wunsch:** Der laufende Tag soll deutlicher auffallen. Aktuell ist nur der Spaltenkörper
+eingefärbt, der Kopfbereich mit "SEP 7 / MONDAY" bleibt weiß.
+
+**Wo:** `globals.css:666` färbt `.weekly-day-column.is-today` mit
+`var(--weekly-today-highlight)`. Der Kopf ist ein eigenes `<header class="weekly-day-header">`
+([WeeklyView.tsx:7089](src/components/WeeklyView.tsx#L7089)) und übermalt die Farbe
+offenbar mit eigenem Hintergrund. Der Wochentagsname hat bereits eine eigene Regel
+(`globals.css:708`, `.weekly-day-name.is-today` setzt nur die Schriftfarbe).
+
+**Zu klären:** Der Kopf ist vermutlich `sticky` und braucht deshalb einen deckenden
+Hintergrund — die Farbe muss also gesetzt, nicht nur geerbt werden.
+
+### I2. Symbole in Kalenderterminen nach oben rechts ✅ *(vom Nutzer bestätigt, Freiraum reicht)*
+- [x] `.event-icons-row` nach oben rechts verschoben, Titel bekommt rechts Freiraum
+
+**Wunsch:** Die kleinen Symbole (Wiederholung, Anbieter) sitzen unten rechts im Termin und
+sollen nach oben rechts.
+
+**Wo:** `globals.css:3183` — `.event-icons-row` hat `bottom: 2px; right: 4px;`. Für oben
+rechts wird daraus `top: 2px; right: 4px;`.
+
+**Achtung:** Der Titel beginnt oben links; bei kurzen Terminen könnten sich Symbole und
+Titel überlappen. Vermutlich braucht die Titelzeile rechts etwas Freiraum
+(`padding-right`), damit nichts verdeckt wird.
+
+---
+
+## Block G — Infrastruktur (Supabase-LXC 201)
+
+### G1. Container läuft privilegiert *(Sicherheitsthema)*
+- [ ] Entscheiden, ob `unprivileged: 0` so bleiben soll
+- [ ] Falls nicht: Container neu aufsetzen und Daten übernehmen
+
+**Warum:** `pct config 201` meldet `unprivileged: 0`. Wer aus diesem Container ausbricht, ist
+**root auf dem NUC** — bei einem Container, der die Datenbank betreibt, die relevantere
+Baustelle als ein fehlendes Root-Passwort. Meist wird das umgestellt, weil Docker im
+unprivilegierten Container zickt; nachvollziehbar, aber ein bewusster Kompromiss.
+
+### G2. Besitzverhältnisse im Dateisystem sind schief
+- [ ] Kurzfix, falls SSH-Zugang zum Container gebraucht wird:
+      `pct exec 201 -- chown 0:0 /etc/passwd` und `pct exec 201 -- chown 0:42 /etc/shadow`
+- [ ] Langfristig: Container sauber neu aufsetzen
+
+**Warum:** Das Dateisystem stammt aus einem **unprivilegierten** Container (alles liegt mit
+UID 100000 auf der Platte), läuft aber jetzt **privilegiert**, also ohne UID-Mapping. root
+besitzt dadurch praktisch keine Datei im System. Zeitstempel belegen es: alles vom 26.02.2026
+mit UID 100000, nur `/etc/hostname` vom 06.09. mit `0:0` — das schreibt Proxmox von außen.
+
+Symptom war `passwd: Authentication token manipulation error`. Das System läuft trotzdem,
+weil root per `CAP_DAC_OVERRIDE` die Rechteprüfung überspringt; Werkzeuge wie `passwd`, die
+strenger prüfen, fallen darüber. Weitere solche Merkwürdigkeiten sind zu erwarten.
+
+⚠️ **Kein `chown -R` über das ganze Dateisystem** — nicht am laufenden Container und schon
+gar nicht mit Docker darin. Postgres und die Supabase-Container haben eigene UIDs (999, 70, …),
+die dabei zerschossen würden.
+
+**Kein Blocker:** `pct enter 201` gibt jederzeit eine Root-Shell ohne Passwort. Ein
+Root-Passwort wird nur für direkten SSH-Zugang gebraucht.
+
+### G3. Supabase Studio ist nicht erreichbar
+- [ ] Auf 201 prüfen: `docker compose ps` — laufen die Container?
+- [ ] Port klären: Studio hängt hinter Kong auf **8000**, nicht 8001
+- [ ] `scripts/supabase-setup.sh` korrigieren: falsche Port-Ausgabe und Shebang `#!/bash`
+
+**Warum:** `http://<IP>:8001` antwortet nicht. Die Zahl stammt aus einer `echo`-Zeile in
+`scripts/supabase-setup.sh`, die nirgends eine Portfreigabe setzt — beim offiziellen
+`supabase/docker`-Stack ist Studio nur über Kong auf 8000 erreichbar. Zusätzlich hat das
+Skript `#!/bash` statt `#!/bin/bash` und ist so gar nicht direkt ausführbar.
+
+---
+
+## Kleinkram (ohne Eile)
+
+- [ ] 114 `console.log` aus dem Produktionscode entfernen (die 275 `console.error` sind in Ordnung)
+- [ ] `NEXTAUTH_SECRET` auf 32 Byte verlängern (erledigt sich mit B3)
+- [ ] API-Routen: JSON-401 statt HTML-Redirect für nicht angemeldete Aufrufe
+- [ ] `deploy.sh` und `docker-compose.yml` löschen oder als veraltet markieren — sie
+      beschreiben ein Portainer-Setup, das nicht mehr verwendet wird
+- [ ] Eigener Auth-Check in `apple/sync` und `weather/geocode` (aktuell nur durch die
+      Middleware geschützt — zusätzliche Absicherung schadet nicht)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "my-weekly-todo-list",
-  "version": "1.121.3",
+  "version": "1.120.1",
   "description": "A web-based weekly task management application that organizes to-dos and calendar events in a single, intuitive weekly view",
   "main": "index.js",
   "scripts": {

src/app/api/calendar/apple/sync/route.ts

@@ -1,18 +1,8 @@
 import { NextResponse } from 'next/server';
-import { getServerSession } from 'next-auth';
 import { getUpcomingEvents } from '@/lib/apple-calendar';
-import { authOptions } from "@/lib/auth";
 
 export async function POST(req: Request) {
     try {
-        // Ohne Anmeldung war diese Route ein offener Relay: beliebige Apple-Zugangsdaten
-        // liessen sich hier gegen Apple durchprobieren. Gleiche Pruefung wie in
-        // /api/calendar/apple/connect.
-        const session = await getServerSession(authOptions);
-        if (!session?.user?.email) {
-            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
-        }
-
         const body = await req.json();
         const { email, password, calendarId, timeMin, timeMax } = body;
 

src/app/globals.css

@@ -3111,18 +3111,6 @@ h3 {
   box-sizing: border-box;
 }
 
-/* Termine ueber Mitternacht: die Schnittkante bleibt offen, damit sichtbar ist,
-   dass der Termin am Nachbartag weiterlaeuft. */
-.time-slot-event.event-continues {
-  border-bottom-right-radius: 0;
-  border-bottom: 2px dashed currentColor;
-}
-
-.time-slot-event.event-continued {
-  border-top-right-radius: 0;
-  border-top: 2px dashed currentColor;
-}
-
 .time-slot-event:has(.event-icons-row) .event-title-row {
   padding-right: 34px;
 }

src/components/AuthForm.tsx

@@ -14,9 +14,13 @@ const AuthForm: React.FC<AuthFormProps> = ({ type, onSubmit, isLoading, error })
 
   const handleSubmit = (e: React.FormEvent) => {
     e.preventDefault();
-    // Kein Logging der Formulardaten: hier stand das Passwort im Klartext in der Browser-Konsole.
+    console.log('📝 AuthForm handleSubmit called with:', { email, password });
+    console.log('📝 onSubmit function is:', typeof onSubmit);
     if (typeof onSubmit === 'function') {
+      console.log('🚀 Calling onSubmit function...');
       onSubmit({ email, password });
+    } else {
+      console.error('❌ onSubmit is not a function!', onSubmit);
     }
   };
 

src/components/WeeklyView.tsx

@@ -108,7 +108,6 @@ import {
     stripHtml, DEFAULT_SOMEDAY_SLOT_COUNT, getSomedaySlotCount, invertColor,
 } from "@/lib/weekly/format";
 import { isAllDayEvent } from "@/lib/weekly/date-utils";
-import { computeEventOverlapLayout } from "@/lib/weekly/event-layout";
 
 // Types
 import UserMenu from "./UserMenu";
@@ -128,7 +127,7 @@ import { getPriorityBadge } from "./weekly/priority-badge";
 export { getPriorityBadge };
 import type {
     RecurringTaskException, ViewStyle, KanbanStage, Task,
-    CalendarEvent, CalendarEventSegment, SomedayList, CellDuration,
+    CalendarEvent, SomedayList, CellDuration,
 } from "@/lib/weekly/types";
 // Re-Export: SettingsSidebar und GridTaskBlock importieren diese Typen historisch von hier
 export type { RecurringTaskException, ViewStyle, KanbanStage, Task, CalendarEvent, SomedayList, CellDuration };
@@ -180,7 +179,6 @@ import {
     getStartOfWeek, formatDateHeader, getDayName, isSameDay, formatDateToISO,
     parseCalendarDate, formatHour, getTimeSlots, getHourFromSlot, getWeekNumber,
     getCWReferenceDate, formatCustomHeader, getSelectedDay,
-    groupEventSegmentsByDay, localDayKey, segmentStartMinutes, segmentEndMinutes,
 } from "@/lib/weekly/date-utils";
 
 
@@ -2620,48 +2618,124 @@ export default function WeeklyView() {
         [tasks, effectiveCellDuration, effectiveShowCompletedTasks, activeProjectFilter],
     );
 
-    // Termine ueber Mitternacht werden je Kalendertag in Abschnitte geteilt:
-    // 22:00-24:00 am Starttag, 00:00-02:00 am Folgetag (siehe splitEventByDay).
-    // Waehrend eines Drags zaehlen die Zeiten aus dem Drag-Zustand, damit sich
-    // die Abschnitte live mitbewegen.
-    const eventSegmentsByDay = useMemo(() => {
-        const dragged = eventDragState?.hasMoved ? eventDragState : null;
-        const events = dragged
-            ? calendarEvents.map((event) =>
-                  event.id === dragged.eventId
-                      ? { ...event, startTime: dragged.currentStartTime, endTime: dragged.currentEndTime }
-                      : event,
-              )
-            : calendarEvents;
-        return groupEventSegmentsByDay(events);
-    }, [calendarEvents, eventDragState]);
-
-    // Get calendar event segments for a specific date (all-day events handled separately)
+    // Get calendar events for a specific date
     const getEventsForDate = useCallback(
-        (date: Date): CalendarEventSegment[] => eventSegmentsByDay.get(localDayKey(date)) ?? [],
-        [eventSegmentsByDay],
-    );
+        (date: Date): CalendarEvent[] => {
+            return calendarEvents.filter((event) => {
+                // Skip all-day events (handled separately)
+                if (isAllDayEvent(event)) return false;
 
-    // Get calendar event segments starting within a specific time slot
-    const getEventsForSlot = useCallback(
-        (date: Date, slot: string): CalendarEventSegment[] => {
-            const [slotHour, slotMinute] = slot.split(":").map(Number);
-            const slotStart = slotHour * 60 + slotMinute;
-            const slotEnd = slotStart + effectiveCellDuration;
-            return getEventsForDate(date).filter((segment) => {
-                const start = segmentStartMinutes(segment);
-                return start >= slotStart && start < slotEnd;
+                const eventDate = new Date(event.startTime);
+                return isSameDay(eventDate, date);
             });
         },
-        [getEventsForDate, effectiveCellDuration],
+        [calendarEvents],
     );
 
-    // Spaltenaufteilung ueberlappender Termine je Tag (siehe lib/weekly/event-layout).
-    const eventOverlapLayout = useMemo(
-        () => computeEventOverlapLayout(eventSegmentsByDay),
-        [eventSegmentsByDay],
+    // Get calendar events for a specific time slot
+    const getEventsForSlot = useCallback(
+        (date: Date, slot: string): CalendarEvent[] => {
+            return calendarEvents.filter((event) => {
+                // Skip all-day events (handled separately)
+                const isAllDay = isAllDayEvent(event);
+                if (isAllDay) return false;
+
+                // During drag, use the drag state's current start time for slot assignment
+                const isDraggedEvent = eventDragState?.eventId === event.id && eventDragState?.hasMoved && eventDragState?.mode === 'move';
+                const startTime = isDraggedEvent ? eventDragState!.currentStartTime : event.startTime;
+
+                const eventDate = new Date(startTime);
+                if (!isSameDay(eventDate, date)) return false;
+
+                // Extract hour:minute from event start time and compare with slot
+                const eventHour = eventDate.getHours();
+                const eventMinute = eventDate.getMinutes();
+
+                // Match if event starts within this slot
+                const [slotHour, slotMinute] = slot.split(":").map(Number);
+                const slotStart = slotHour * 60 + slotMinute;
+                const slotEnd = slotStart + effectiveCellDuration;
+                const eventStart = eventHour * 60 + eventMinute;
+
+                return eventStart >= slotStart && eventStart < slotEnd;
+            });
+        },
+        [calendarEvents, effectiveCellDuration, eventDragState],
     );
 
+    // Precompute overlap layout: { [eventId]: { column, totalColumns } }
+    const eventOverlapLayout = useMemo(() => {
+        const layout: Record<string, { column: number; totalColumns: number }> = {};
+        // Group events by day
+        const dayMap = new Map<string, CalendarEvent[]>();
+        for (const event of calendarEvents) {
+            if (isAllDayEvent(event)) continue;
+            const d = new Date(event.startTime);
+            const key = `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+            if (!dayMap.has(key)) dayMap.set(key, []);
+            dayMap.get(key)!.push(event);
+        }
+        for (const events of dayMap.values()) {
+            // Sort by start time, then by duration (longer first)
+            events.sort((a, b) => {
+                const diff = new Date(a.startTime).getTime() - new Date(b.startTime).getTime();
+                if (diff !== 0) return diff;
+                return (new Date(b.endTime).getTime() - new Date(b.startTime).getTime()) -
+                       (new Date(a.endTime).getTime() - new Date(a.startTime).getTime());
+            });
+            // Build overlap groups using a greedy column assignment
+            const columns: { end: number; eventId: string }[][] = [];
+            for (const event of events) {
+                const start = new Date(event.startTime).getTime();
+                const end = new Date(event.endTime).getTime();
+                // Find first column where this event doesn't overlap
+                let placed = false;
+                for (let col = 0; col < columns.length; col++) {
+                    const lastInCol = columns[col][columns[col].length - 1];
+                    if (lastInCol.end <= start) {
+                        columns[col].push({ end, eventId: event.id });
+                        placed = true;
+                        break;
+                    }
+                }
+                if (!placed) {
+                    columns.push([{ end, eventId: event.id }]);
+                }
+            }
+            // Now find the max columns each event actually shares with
+            // For each event, find all events that overlap it and determine the group width
+            for (const event of events) {
+                const start = new Date(event.startTime).getTime();
+                const end = new Date(event.endTime).getTime();
+                // Count how many columns have events overlapping this time range
+                let overlappingCols = 0;
+                for (const col of columns) {
+                    for (const item of col) {
+                        const itemStart = calendarEvents.find(e => e.id === item.eventId);
+                        if (itemStart) {
+                            const iStart = new Date(itemStart.startTime).getTime();
+                            const iEnd = new Date(itemStart.endTime).getTime();
+                            if (iStart < end && iEnd > start) {
+                                overlappingCols++;
+                                break;
+                            }
+                        }
+                    }
+                }
+                // Find which column this event is in
+                let eventCol = 0;
+                for (let col = 0; col < columns.length; col++) {
+                    if (columns[col].some(item => item.eventId === event.id)) {
+                        eventCol = col;
+                        break;
+                    }
+                }
+                layout[event.id] = { column: eventCol, totalColumns: Math.max(overlappingCols, 1) };
+            }
+        }
+        return layout;
+    }, [calendarEvents]);
+
     // Calculate event duration in pixels for proper height display
     const getEventDuration = (event: CalendarEvent): number => {
         if (isAllDayEvent(event)) return 0; // All-day events handled separately
@@ -3294,19 +3368,25 @@ export default function WeeklyView() {
             const [slotHour, slotMinute] = slot.split(":").map(Number);
             const slotStart = slotHour * 60 + slotMinute;
 
-            return getEventsForDate(date).some((segment) => {
+            return calendarEvents.some((event) => {
+                if (isAllDayEvent(event)) return false;
                 // Skip events that have been unlocked by the user
-                if (unlockedEvents.has(segment.id)) return false;
+                if (unlockedEvents.has(event.id)) return false;
 
-                // Only protect if the slot start time falls within the segment's
-                // duration on this day; a segment ending at midnight covers up to 24:00.
-                return (
-                    slotStart >= segmentStartMinutes(segment) &&
-                    slotStart < segmentEndMinutes(segment)
-                );
+                const eventDate = new Date(event.startTime);
+                if (!isSameDay(eventDate, date)) return false;
+
+                const eventStart = eventDate.getHours() * 60 + eventDate.getMinutes();
+                const eventEndDate = new Date(event.endTime);
+                const eventEndMinutes =
+                    eventEndDate.getHours() * 60 + eventEndDate.getMinutes();
+
+                // Only protect if the slot start time falls within the event's actual duration
+                // This ensures protection matches exactly what the event covers
+                return slotStart >= eventStart && slotStart < eventEndMinutes;
             });
         },
-        [protectEventTimes, getEventsForDate, unlockedEvents],
+        [protectEventTimes, calendarEvents, unlockedEvents],
     );
 
     // Check if a slot is occupied by any task (to prevent stacking)
@@ -7128,6 +7208,7 @@ export default function WeeklyView() {
                                         {/* Protection overlays - render at exact event positions */}
                                         {protectEventTimes &&
                                             getEventsForDate(date)
+                                                .filter((e) => !isAllDayEvent(e))
                                                 .map((event) => {
                                                     const eventStart = new Date(event.startTime);
                                                     const eventEnd = new Date(event.endTime);
@@ -7162,7 +7243,7 @@ export default function WeeklyView() {
 
                                                     return (
                                                         <div
-                                                            key={`protection-${event.segmentKey}`}
+                                                            key={`protection-${event.id}`}
                                                             className="event-protection-overlay"
                                                             style={{
                                                                 position: "absolute",
@@ -7369,27 +7450,15 @@ export default function WeeklyView() {
                                                     )}
                                                     {/* Calendar Events in time slot */}
                                                     {slotEvents.map((event) => {
-                                                        // event ist ein Tagesabschnitt: bei Terminen ueber Mitternacht sind
-                                                        // startTime/endTime auf diesen Tag beschnitten. Die Drag-Zeiten sind
-                                                        // bereits in eventSegmentsByDay eingerechnet.
+                                                        // During drag, use the drag state's current times for position/height
                                                         const isDragging = eventDragState?.eventId === event.id && eventDragState?.hasMoved;
-                                                        const displayStartTime = new Date(event.startTime);
-                                                        const displayEndTime = new Date(event.endTime);
+                                                        const displayStartTime = isDragging ? new Date(eventDragState!.currentStartTime) : new Date(event.startTime);
+                                                        const displayEndTime = isDragging ? new Date(eventDragState!.currentEndTime) : new Date(event.endTime);
                                                         const durationMs = displayEndTime.getTime() - displayStartTime.getTime();
                                                         const durationMinutes = durationMs / (1000 * 60);
                                                         const pxPerMin = getSlotHeight(effectiveCellDuration) / effectiveCellDuration;
                                                         const eventHeight = Math.max(durationMinutes * pxPerMin, 15);
-                                                        const pad = (value: number) => value.toString().padStart(2, "0");
-                                                        const startLabel = event.continuesFromPreviousDay
-                                                            ? "00:00"
-                                                            : `${pad(displayStartTime.getHours())}:${pad(displayStartTime.getMinutes())}`;
-                                                        const endLabel = event.continuesOnNextDay
-                                                            ? "24:00"
-                                                            : `${pad(displayEndTime.getHours())}:${pad(displayEndTime.getMinutes())}`;
-                                                        const timeStr = `${startLabel} - ${endLabel}`;
-                                                        const fullStart = new Date(event.sourceEvent.startTime);
-                                                        const fullEnd = new Date(event.sourceEvent.endTime);
-                                                        const fullTimeStr = `${pad(fullStart.getHours())}:${pad(fullStart.getMinutes())} - ${pad(fullEnd.getHours())}:${pad(fullEnd.getMinutes())}`;
+                                                        const timeStr = `${displayStartTime.getHours().toString().padStart(2, "0")}:${displayStartTime.getMinutes().toString().padStart(2, "0")} - ${displayEndTime.getHours().toString().padStart(2, "0")}:${displayEndTime.getMinutes().toString().padStart(2, "0")}`;
 
                                                         // Calculate offset within the slot based on event start time
                                                         const [slotHour, slotMinute] = slot
@@ -7415,15 +7484,15 @@ export default function WeeklyView() {
                                                             ? `color-mix(in srgb, ${eventColor} 30%, #0f172a)`
                                                             : borderColor;
 
-                                                        const overlap = eventOverlapLayout[event.segmentKey] || { column: 0, totalColumns: 1 };
+                                                        const overlap = eventOverlapLayout[event.id] || { column: 0, totalColumns: 1 };
                                                         const colWidth = 100 / overlap.totalColumns;
                                                         const colLeft = overlap.column * colWidth;
 
                                                         return (
                                                             <div
-                                                                key={event.segmentKey}
-                                                                className={`time-slot-event${isDragging ? ' event-dragging' : ''}${event.continuesFromPreviousDay ? ' event-continued' : ''}${event.continuesOnNextDay ? ' event-continues' : ''}`}
-                                                                title={`${event.calendarTitle}: ${event.title}\n${event.segmentCount > 1 ? fullTimeStr : timeStr}`}
+                                                                key={event.id}
+                                                                className={`time-slot-event${isDragging ? ' event-dragging' : ''}`}
+                                                                title={`${event.calendarTitle}: ${event.title}\n${timeStr}`}
                                                                 style={{
                                                                     height: `${eventHeight}px`,
                                                                     minHeight: `15px`,
@@ -7451,23 +7520,23 @@ export default function WeeklyView() {
                                                                     if (event.editable) {
                                                                         setCalendarEventModal({
                                                                             isOpen: true,
-                                                                            event: event.sourceEvent,
+                                                                            event: event,
                                                                         });
                                                                     }
                                                                 }}
                                                                 onMouseDown={(e) => {
                                                                     if (event.editable && e.button === 0) {
-                                                                        handleEventDragStart(e, event.sourceEvent, 'move');
+                                                                        handleEventDragStart(e, event, 'move');
                                                                     }
                                                                 }}
                                                             >
-                                                                {/* Top resize handle - nur am tatsaechlichen Terminbeginn */}
-                                                                {event.editable && !event.continuesFromPreviousDay && (
+                                                                {/* Top resize handle */}
+                                                                {event.editable && (
                                                                     <div
                                                                         className="event-resize-handle event-resize-handle-top"
                                                                         onMouseDown={(e) => {
                                                                             e.stopPropagation();
-                                                                            handleEventDragStart(e, event.sourceEvent, 'resize-top');
+                                                                            handleEventDragStart(e, event, 'resize-top');
                                                                         }}
                                                                     />
                                                                 )}
@@ -7493,13 +7562,13 @@ export default function WeeklyView() {
                                                                         style={{ fontSize: '0.6rem' }}
                                                                     />
                                                                 </div>
-                                                                {/* Bottom resize handle - nur am tatsaechlichen Terminende */}
-                                                                {event.editable && !event.continuesOnNextDay && (
+                                                                {/* Bottom resize handle */}
+                                                                {event.editable && (
                                                                     <div
                                                                         className="event-resize-handle event-resize-handle-bottom"
                                                                         onMouseDown={(e) => {
                                                                             e.stopPropagation();
-                                                                            handleEventDragStart(e, event.sourceEvent, 'resize-bottom');
+                                                                            handleEventDragStart(e, event, 'resize-bottom');
                                                                         }}
                                                                     />
                                                                 )}
@@ -7582,14 +7651,14 @@ export default function WeeklyView() {
 
                                             return (
                                                 <div
-                                                    key={event.segmentKey}
+                                                    key={event.id}
                                                     className="weekly-calendar-event"
                                                     onClick={(e) => {
                                                         e.stopPropagation();
                                                         if (event.editable) {
                                                             setCalendarEventModal({
                                                                 isOpen: true,
-                                                                event: event.sourceEvent,
+                                                                event: event,
                                                             });
                                                         }
                                                     }}

src/lib/weekly/date-utils.ts

@@ -1,4 +1,4 @@
-import type { CellDuration, CalendarEvent, CalendarEventSegment } from "@/lib/weekly/types";
+import type { CellDuration, CalendarEvent } from "@/lib/weekly/types";
 
 /**
  * Datums-, Wochen- und Zeitraster-Helfer der Wochenansicht.
@@ -220,125 +220,3 @@ export const isAllDayEvent = (event: CalendarEvent): boolean => {
     // If it's effectively 24h+ and starts at midnight (local or UTC), treat as all-day
     return durationHours >= 24 && (isLocalMidnight || isUTCMidnight);
 };
-
-/**
- * Aufteilung von Terminen an der Tagesgrenze.
- *
- * Ein Termin von 22:00 bis 02:00 gehoert in der Wochenansicht nicht als ein
- * ueberlanger Block in den Starttag, sondern als zwei Abschnitte: 22:00-24:00
- * am Starttag und 00:00-02:00 am Folgetag. Die Regeln stehen hier als reine
- * Funktionen, damit sie ohne Browser testbar bleiben.
- */
-
-const MS_PER_MINUTE = 60 * 1000;
-
-/** Lokale Mitternacht des Tages, in dem `date` liegt. */
-function startOfLocalDay(date: Date): Date {
-    return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
-}
-
-/** Lokale Mitternacht des Folgetages; ueber Kalenderarithmetik, damit DST passt. */
-function startOfNextLocalDay(date: Date): Date {
-    return new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1, 0, 0, 0, 0);
-}
-
-/** Stabiler Tagesschluessel in lokaler Zeit (YYYY-MM-DD). */
-export function localDayKey(date: Date): string {
-    const month = String(date.getMonth() + 1).padStart(2, "0");
-    const day = String(date.getDate()).padStart(2, "0");
-    return `${date.getFullYear()}-${month}-${day}`;
-}
-
-function makeSegment(
-    event: CalendarEvent,
-    segmentStart: Date,
-    segmentEnd: Date,
-    index: number,
-    count: number,
-): CalendarEventSegment {
-    return {
-        ...event,
-        startTime: segmentStart.toISOString(),
-        endTime: segmentEnd.toISOString(),
-        segmentKey: count > 1 ? `${event.id}#${localDayKey(segmentStart)}` : event.id,
-        segmentIndex: index,
-        segmentCount: count,
-        continuesFromPreviousDay: index > 0,
-        continuesOnNextDay: index < count - 1,
-        sourceEvent: event,
-    };
-}
-
-/**
- * Zerlegt einen Termin in Abschnitte je Kalendertag.
- *
- * Ganztagstermine, ungueltige Zeiten und Termine ohne positive Dauer ergeben
- * genau einen Abschnitt mit den Originalzeiten. Ein Termin, der punktgenau um
- * Mitternacht endet, erzeugt keinen leeren Abschnitt am Folgetag.
- */
-export function splitEventByDay(event: CalendarEvent): CalendarEventSegment[] {
-    const start = parseCalendarDate(event.startTime);
-    const end = event.endTime ? parseCalendarDate(event.endTime) : start;
-
-    const unsplittable =
-        isAllDayEvent(event) ||
-        Number.isNaN(start.getTime()) ||
-        Number.isNaN(end.getTime()) ||
-        end.getTime() <= start.getTime();
-
-    if (unsplittable) {
-        return [makeSegment(event, start, end, 0, 1)];
-    }
-
-    // Grenzen einsammeln: Start, jede dazwischenliegende Mitternacht, Ende.
-    const boundaries: Date[] = [start];
-    let cursor = startOfNextLocalDay(start);
-    while (cursor.getTime() < end.getTime()) {
-        boundaries.push(cursor);
-        cursor = startOfNextLocalDay(cursor);
-    }
-    boundaries.push(end);
-
-    const count = boundaries.length - 1;
-    const segments: CalendarEventSegment[] = [];
-    for (let i = 0; i < count; i++) {
-        segments.push(makeSegment(event, boundaries[i], boundaries[i + 1], i, count));
-    }
-    return segments;
-}
-
-/** Abschnitte aller Termine ohne Ganztagstermine, gruppiert nach lokalem Tag. */
-export function groupEventSegmentsByDay(
-    events: CalendarEvent[],
-): Map<string, CalendarEventSegment[]> {
-    const byDay = new Map<string, CalendarEventSegment[]>();
-    for (const event of events) {
-        if (isAllDayEvent(event)) continue;
-        for (const segment of splitEventByDay(event)) {
-            const key = localDayKey(new Date(segment.startTime));
-            const bucket = byDay.get(key);
-            if (bucket) {
-                bucket.push(segment);
-            } else {
-                byDay.set(key, [segment]);
-            }
-        }
-    }
-    return byDay;
-}
-
-/** Minuten seit lokaler Mitternacht des Abschnittstages. */
-export function segmentStartMinutes(segment: CalendarEventSegment): number {
-    const start = new Date(segment.startTime);
-    return start.getHours() * 60 + start.getMinutes();
-}
-
-/**
- * Ende des Abschnitts in Minuten ab Mitternacht des Abschnittstages.
- * Ein bis Mitternacht laufender Abschnitt liefert 1440 statt 0.
- */
-export function segmentEndMinutes(segment: CalendarEventSegment): number {
-    const start = new Date(segment.startTime);
-    const end = new Date(segment.endTime);
-    return Math.round((end.getTime() - startOfLocalDay(start).getTime()) / MS_PER_MINUTE);
-}

src/lib/weekly/event-layout.ts

@@ -1,79 +0,0 @@
-import type { CalendarEventSegment } from "@/lib/weekly/types";
-
-/**
- * Spaltenaufteilung sich ueberlappender Termine im Tagesraster.
- *
- * Reine Funktionen ohne Komponenten-State und ohne Laufzeit-Importe, damit die
- * Regeln mit node:test pruefbar bleiben — lagen bis v1.121.2 in WeeklyView.tsx.
- */
-
-export interface EventColumnPlacement {
-    /** 0-basierte Spalte innerhalb der Ueberlappungsgruppe. */
-    column: number;
-    /** Breite der Gruppe in Spalten; mindestens 1. */
-    totalColumns: number;
-}
-
-const startMs = (segment: CalendarEventSegment): number =>
-    new Date(segment.startTime).getTime();
-const endMs = (segment: CalendarEventSegment): number =>
-    new Date(segment.endTime).getTime();
-
-/**
- * Ordnet die Abschnitte eines Tages in Spalten an.
- *
- * Frueher Start zuerst, bei gleichem Start der laengere Termin. Jeder Abschnitt
- * kommt in die erste Spalte, deren letzter Eintrag bereits beendet ist. Die
- * Gruppenbreite ist die Anzahl der Spalten, die den Abschnitt zeitlich schneiden.
- */
-export function layoutDaySegments(
-    daySegments: CalendarEventSegment[],
-): Record<string, EventColumnPlacement> {
-    const layout: Record<string, EventColumnPlacement> = {};
-
-    const segments = [...daySegments].sort((a, b) => {
-        const byStart = startMs(a) - startMs(b);
-        if (byStart !== 0) return byStart;
-        return endMs(b) - startMs(b) - (endMs(a) - startMs(a));
-    });
-
-    const columns: CalendarEventSegment[][] = [];
-    for (const segment of segments) {
-        const free = columns.find((col) => endMs(col[col.length - 1]) <= startMs(segment));
-        if (free) {
-            free.push(segment);
-        } else {
-            columns.push([segment]);
-        }
-    }
-
-    for (const segment of segments) {
-        const start = startMs(segment);
-        const end = endMs(segment);
-        let overlappingCols = 0;
-        let segmentCol = 0;
-        columns.forEach((col, index) => {
-            if (col.some((other) => startMs(other) < end && endMs(other) > start)) {
-                overlappingCols++;
-            }
-            if (col.includes(segment)) segmentCol = index;
-        });
-        layout[segment.segmentKey] = {
-            column: segmentCol,
-            totalColumns: Math.max(overlappingCols, 1),
-        };
-    }
-
-    return layout;
-}
-
-/** Spaltenaufteilung fuer alle Tage, gebuendelt nach segmentKey. */
-export function computeEventOverlapLayout(
-    segmentsByDay: Map<string, CalendarEventSegment[]>,
-): Record<string, EventColumnPlacement> {
-    const layout: Record<string, EventColumnPlacement> = {};
-    for (const daySegments of segmentsByDay.values()) {
-        Object.assign(layout, layoutDaySegments(daySegments));
-    }
-    return layout;
-}

src/lib/weekly/types.ts

@@ -95,26 +95,3 @@ export interface SomedayList {
 
 // Time grid configuration options
 export type CellDuration = 15 | 20 | 30 | 60;
-
-/**
- * Ein auf genau einen Kalendertag zugeschnittener Abschnitt eines Termins.
- *
- * Termine ueber Mitternacht werden in der Wochenansicht je Tag dargestellt:
- * 22:00-24:00 am Starttag, 00:00-02:00 am Folgetag. startTime/endTime sind die
- * beschnittenen Zeiten des Abschnitts; sourceEvent traegt den unveraenderten
- * Termin fuer Klick, Drag und Speichern.
- */
-export interface CalendarEventSegment extends CalendarEvent {
-    /** Eindeutig pro Abschnitt; als React-Key und fuer das Overlap-Layout. */
-    segmentKey: string;
-    /** 0-basierter Index dieses Abschnitts innerhalb des Termins. */
-    segmentIndex: number;
-    /** Anzahl der Abschnitte des Termins insgesamt. */
-    segmentCount: number;
-    /** Termin hat bereits an einem frueheren Tag begonnen. */
-    continuesFromPreviousDay: boolean;
-    /** Termin laeuft am Folgetag weiter. */
-    continuesOnNextDay: boolean;
-    /** Der ungeteilte Termin mit den Originalzeiten. */
-    sourceEvent: CalendarEvent;
-}

tests/unit/date-utils.test.ts

@@ -3,8 +3,7 @@ import assert from "node:assert/strict";
 import {
     getStartOfWeek, getDayName, isSameDay, formatDateToISO, parseCalendarDate,
     formatHour, getTimeSlots, getHourFromSlot, getWeekNumber, getCWReferenceDate,
-    getSelectedDay, splitEventByDay, groupEventSegmentsByDay,
-    segmentStartMinutes, segmentEndMinutes,
+    getSelectedDay,
 } from "../../src/lib/weekly/date-utils.ts";
 
 /**
@@ -229,121 +228,3 @@ describe("getDayName", () => {
         assert.equal(getDayName(new Date(2026, 8, 7), "de-DE", undefined, undefined, 0, "uppercase"), "MONTAG");
     });
 });
-
-/**
- * Termine über Mitternacht.
- *
- * Erwartetes Nutzerverhalten: Ein Termin von 22:00 bis 02:00 verlängert nicht den
- * Starttag, sondern wird an der Tagesgrenze geteilt und läuft am Folgetag weiter —
- * so, wie es Kalender-Apps zeigen.
- */
-describe("splitEventByDay", () => {
-    const iso = (y: number, m: number, d: number, h: number, min = 0) =>
-        new Date(y, m, d, h, min, 0, 0).toISOString();
-
-    const event = (startTime: string, endTime: string, id = "e1") => ({
-        id,
-        title: "Termin",
-        startTime,
-        endTime,
-        source: "google" as const,
-    });
-
-    test("Termin innerhalb eines Tages bleibt ein Abschnitt", () => {
-        const segments = splitEventByDay(event(iso(2026, 8, 10, 9), iso(2026, 8, 10, 10, 30)));
-        assert.equal(segments.length, 1);
-        assert.equal(segments[0].continuesFromPreviousDay, false);
-        assert.equal(segments[0].continuesOnNextDay, false);
-        assert.equal(segments[0].segmentKey, "e1");
-    });
-
-    test("22:00 bis 02:00 ergibt zwei Abschnitte an der Tagesgrenze", () => {
-        const segments = splitEventByDay(event(iso(2026, 8, 10, 22), iso(2026, 8, 11, 2)));
-        assert.equal(segments.length, 2);
-
-        const first = new Date(segments[0].startTime);
-        const firstEnd = new Date(segments[0].endTime);
-        assert.equal(first.getHours(), 22);
-        assert.equal(firstEnd.getDate(), 11);
-        assert.equal(firstEnd.getHours(), 0);
-        assert.equal(segments[0].continuesOnNextDay, true);
-
-        const second = new Date(segments[1].startTime);
-        const secondEnd = new Date(segments[1].endTime);
-        assert.equal(second.getDate(), 11);
-        assert.equal(second.getHours(), 0);
-        assert.equal(second.getMinutes(), 0);
-        assert.equal(secondEnd.getHours(), 2);
-        assert.equal(segments[1].continuesFromPreviousDay, true);
-        assert.equal(segments[1].continuesOnNextDay, false);
-    });
-
-    test("kein Abschnitt verliert Zeit: Summe der Abschnitte ist die Termindauer", () => {
-        const start = iso(2026, 8, 10, 22);
-        const end = iso(2026, 8, 13, 3, 15);
-        const segments = splitEventByDay(event(start, end));
-        const total = segments.reduce(
-            (sum, s) => sum + (new Date(s.endTime).getTime() - new Date(s.startTime).getTime()),
-            0,
-        );
-        assert.equal(total, new Date(end).getTime() - new Date(start).getTime());
-    });
-
-    test("Termin über drei Tage ergibt drei Abschnitte mit vollem Mitteltag", () => {
-        const segments = splitEventByDay(event(iso(2026, 8, 10, 23), iso(2026, 8, 12, 1)));
-        assert.equal(segments.length, 3);
-        const middle = segments[1];
-        assert.equal(new Date(middle.startTime).getHours(), 0);
-        assert.equal(new Date(middle.endTime).getDate(), 12);
-        assert.equal(middle.continuesFromPreviousDay, true);
-        assert.equal(middle.continuesOnNextDay, true);
-    });
-
-    test("Ende exakt um Mitternacht erzeugt keinen leeren Abschnitt am Folgetag", () => {
-        const segments = splitEventByDay(event(iso(2026, 8, 10, 22), iso(2026, 8, 11, 0)));
-        assert.equal(segments.length, 1);
-        assert.equal(segments[0].continuesOnNextDay, false);
-    });
-
-    test("Abschnitte eines Termins haben unterschiedliche Keys, aber dieselbe Event-Id", () => {
-        const segments = splitEventByDay(event(iso(2026, 8, 10, 22), iso(2026, 8, 11, 2)));
-        assert.notEqual(segments[0].segmentKey, segments[1].segmentKey);
-        assert.equal(segments[0].id, "e1");
-        assert.equal(segments[1].id, "e1");
-        assert.equal(segments[1].sourceEvent.startTime, iso(2026, 8, 10, 22));
-        assert.equal(segments[1].sourceEvent.endTime, iso(2026, 8, 11, 2));
-    });
-
-    test("Ganztagstermin wird nicht geteilt", () => {
-        const segments = splitEventByDay(event("2026-09-10", "2026-09-12"));
-        assert.equal(segments.length, 1);
-        assert.equal(segments[0].segmentCount, 1);
-    });
-
-    test("Ende vor Start bleibt ein Abschnitt und wirft nicht", () => {
-        const segments = splitEventByDay(event(iso(2026, 8, 10, 12), iso(2026, 8, 10, 11)));
-        assert.equal(segments.length, 1);
-    });
-});
-
-describe("Tagesgruppierung und Minutenumrechnung der Abschnitte", () => {
-    const iso = (y: number, m: number, d: number, h: number, min = 0) =>
-        new Date(y, m, d, h, min, 0, 0).toISOString();
-
-    test("Abschnitte landen im jeweiligen Tag", () => {
-        const byDay = groupEventSegmentsByDay([
-            { id: "a", title: "Nacht", startTime: iso(2026, 8, 10, 22), endTime: iso(2026, 8, 11, 2), source: "google" },
-            { id: "b", title: "Tag", startTime: iso(2026, 8, 11, 9), endTime: iso(2026, 8, 11, 10), source: "google" },
-        ]);
-        assert.equal(byDay.get("2026-09-10")?.length, 1);
-        assert.equal(byDay.get("2026-09-11")?.length, 2);
-    });
-
-    test("bis Mitternacht laufender Abschnitt endet bei Minute 1440, nicht bei 0", () => {
-        const [first] = splitEventByDay({
-            id: "a", title: "Nacht", startTime: iso(2026, 8, 10, 22), endTime: iso(2026, 8, 11, 2), source: "google",
-        });
-        assert.equal(segmentStartMinutes(first), 22 * 60);
-        assert.equal(segmentEndMinutes(first), 24 * 60);
-    });
-});

tests/unit/event-layout.test.ts

@@ -1,74 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-import { layoutDaySegments, computeEventOverlapLayout } from "../../src/lib/weekly/event-layout.ts";
-import type { CalendarEventSegment } from "../../src/lib/weekly/types.ts";
-
-/**
- * Charakterisierungstests der Spaltenaufteilung im Tagesraster.
- *
- * Beobachtbares Verhalten: Termine, die sich zeitlich überschneiden, stehen
- * nebeneinander statt übereinander; Termine, die sich nicht berühren, bekommen
- * die volle Breite.
- */
-
-const at = (h: number, min = 0) => new Date(2026, 8, 10, h, min, 0, 0).toISOString();
-
-const segment = (key: string, startHour: number, endHour: number): CalendarEventSegment => ({
-    id: key,
-    title: key,
-    startTime: at(startHour),
-    endTime: at(endHour),
-    source: "google",
-    segmentKey: key,
-    segmentIndex: 0,
-    segmentCount: 1,
-    continuesFromPreviousDay: false,
-    continuesOnNextDay: false,
-    sourceEvent: { id: key, title: key, startTime: at(startHour), endTime: at(endHour), source: "google" },
-});
-
-describe("layoutDaySegments", () => {
-    test("ein einzelner Termin nimmt die volle Breite ein", () => {
-        const layout = layoutDaySegments([segment("a", 9, 10)]);
-        assert.deepEqual(layout.a, { column: 0, totalColumns: 1 });
-    });
-
-    test("zwei überschneidende Termine teilen sich zwei Spalten", () => {
-        const layout = layoutDaySegments([segment("a", 9, 11), segment("b", 10, 12)]);
-        assert.equal(layout.a.totalColumns, 2);
-        assert.equal(layout.b.totalColumns, 2);
-        assert.notEqual(layout.a.column, layout.b.column);
-    });
-
-    test("aufeinanderfolgende Termine bekommen dieselbe Spalte und volle Breite", () => {
-        const layout = layoutDaySegments([segment("a", 9, 10), segment("b", 10, 11)]);
-        assert.deepEqual(layout.a, { column: 0, totalColumns: 1 });
-        assert.deepEqual(layout.b, { column: 0, totalColumns: 1 });
-    });
-
-    test("drei gleichzeitige Termine ergeben drei Spalten", () => {
-        const layout = layoutDaySegments([segment("a", 9, 12), segment("b", 9, 12), segment("c", 9, 12)]);
-        const columns = ["a", "b", "c"].map((k) => layout[k].column).sort();
-        assert.deepEqual(columns, [0, 1, 2]);
-        assert.equal(layout.a.totalColumns, 3);
-    });
-
-    test("die Reihenfolge der Eingabe ändert das Ergebnis nicht", () => {
-        const forward = layoutDaySegments([segment("a", 9, 11), segment("b", 10, 12)]);
-        const backward = layoutDaySegments([segment("b", 10, 12), segment("a", 9, 11)]);
-        assert.deepEqual(forward, backward);
-    });
-});
-
-describe("computeEventOverlapLayout", () => {
-    test("fasst mehrere Tage in einer Zuordnung zusammen", () => {
-        const layout = computeEventOverlapLayout(
-            new Map([
-                ["2026-09-10", [segment("a", 9, 11), segment("b", 10, 12)]],
-                ["2026-09-11", [segment("c", 9, 10)]],
-            ]),
-        );
-        assert.equal(layout.a.totalColumns, 2);
-        assert.equal(layout.c.totalColumns, 1);
-    });
-});