From 58b5e6b07462dc6ab66b2c7a1bb5f211427977df Mon Sep 17 00:00:00 2001
From: Carsten Graf <reptil1990@me.com>
Date: Tue, 23 Sep 2025 14:13:24 +0200
Subject: [PATCH] Update

---
 .dockerignore                                 |    1 +
 .gitignore                                    |  107 +
 ACHIEVEMENTS.md                               |  217 +
 API.md                                        |  779 ++
 README.md                                     |  222 +
 apache-ssl-config.conf                        |   51 +
 config/blacklist-db.js                        |  335 +
 config/blacklist.js                           |  176 +
 config/levenshtein.js                         |  336 +
 docker-compose.yml                            |   20 +
 dockerfile                                    |   18 +
 lib/achievementSystem.js                      |  880 ++
 lib/push-service.js                           |  162 +
 ninjacross-8a77c8ef79a7.json                  |   13 +
 package-lock.json                             | 7461 +++++++++++++++++
 package.json                                  |   47 +
 pentest/enumerate.py                          |  187 +
 pentest/realistic_enumeration.py              |  312 +
 public/404.html                               |  336 +
 public/admin-dashboard.html                   |  254 +
 public/adminlogin.html                        |   55 +
 public/agb.html                               |  244 +
 public/css/admin-dashboard.css                |  753 ++
 public/css/adminlogin.css                     |  294 +
 public/css/dashboard.css                      | 1981 +++++
 public/css/generator.css                      |  500 ++
 public/css/index.css                          | 1289 +++
 public/css/login.css                          |  486 ++
 public/css/reset-password.css                 |  305 +
 public/dashboard.html                         |  902 ++
 public/datenschutz.html                       |  362 +
 .../EMAIL-COMPATIBILITY-GUIDE.md              |  181 +
 public/email-templates/README.md              |  157 +
 public/email-templates/TEMPLATES-OVERVIEW.md  |  119 +
 .../URL-CONFIGURATION-GUIDE.md                |  174 +
 public/email-templates/change-email.html      |  274 +
 public/email-templates/change-email.txt       |   29 +
 public/email-templates/invite-user.html       |  300 +
 public/email-templates/invite-user.txt        |   34 +
 public/email-templates/magic-link.html        |  257 +
 public/email-templates/magic-link.txt         |   25 +
 public/email-templates/reauthentication.html  |  327 +
 public/email-templates/reauthentication.txt   |   30 +
 .../reset-password-compatible.html            |  249 +
 .../reset-password-optimized.html             |  301 +
 .../email-templates/reset-password-table.html |  323 +
 public/email-templates/reset-password.html    |  294 +
 public/email-templates/reset-password.txt     |   32 +
 .../welcome-email-compatible.html             |  208 +
 .../email-templates/welcome-email-simple.html |  187 +
 public/email-templates/welcome-email.html     |  274 +
 public/email-templates/welcome-email.txt      |   32 +
 public/generator.html                         |   85 +
 public/impressum.html                         |  241 +
 public/index.html                             |  262 +
 public/js/admin-dashboard.js                  | 1768 ++++
 public/js/adminlogin.js                       |   91 +
 public/js/cookie-consent.js                   |  601 ++
 public/js/cookie-utils.js                     |  105 +
 public/js/dashboard.js                        | 2163 +++++
 public/js/generator.js                        |  573 ++
 public/js/index.js                            |  808 ++
 public/js/login.js                            |  291 +
 public/js/page-tracking.js                    |   33 +
 public/js/reset-password.js                   |  202 +
 public/login.html                             |  121 +
 public/manifest.json                          |   55 +
 public/pictures/favicon.ico                   |  Bin 0 -> 15299 bytes
 public/pictures/icon-192.png                  |  Bin 0 -> 5560 bytes
 public/reset-password.html                    |   81 +
 public/sw.js                                  |  137 +
 public/test-push.html                         |  560 ++
 routes/api.js                                 | 4969 +++++++++++
 routes/public.js                              |  176 +
 scripts/best_time_achievements.js             |  198 +
 scripts/best_time_notifications.js            |  141 +
 scripts/create-user.js                        |  109 +
 scripts/daily_achievements.js                 |  110 +
 scripts/enhanced_player_notifications.js      |  285 +
 scripts/fix_player_subscriptions.js           |  134 +
 scripts/init-db.js                            |  107 +
 scripts/iphone_notifications.js               |  129 +
 scripts/setup-players.js                      |   87 +
 scripts/setup_cron.js                         |  108 +
 scripts/simulate-new-time.js                  |   94 +
 scripts/test-achievements.js                  |   50 +
 scripts/test-immediate-achievements.js        |   48 +
 scripts/test-multiple-achievements.js         |   75 +
 server.js                                     |  380 +
 ssl-setup-guide.md                            |   89 +
 swagger.js                                    |  285 +
 test-achievements.js                          |   46 +
 wiki/API-Referenz.md                          |  752 ++
 wiki/Achievement-System.md                    |  479 ++
 wiki/Benutzerhandbuch.md                      |  261 +
 wiki/Datenbank.md                             |  588 ++
 wiki/Deployment.md                            |  642 ++
 wiki/Entwicklerhandbuch.md                    |  589 ++
 wiki/FAQ.md                                   |  380 +
 wiki/Home.md                                  |   92 +
 wiki/Schnellstart.md                          |  220 +
 wiki/Sicherheit.md                            |  621 ++
 wiki/Troubleshooting.md                       |  687 ++
 103 files changed, 44000 insertions(+)
 create mode 100644 .dockerignore
 create mode 100644 .gitignore
 create mode 100644 ACHIEVEMENTS.md
 create mode 100644 API.md
 create mode 100644 README.md
 create mode 100644 apache-ssl-config.conf
 create mode 100644 config/blacklist-db.js
 create mode 100644 config/blacklist.js
 create mode 100644 config/levenshtein.js
 create mode 100644 docker-compose.yml
 create mode 100644 dockerfile
 create mode 100644 lib/achievementSystem.js
 create mode 100644 lib/push-service.js
 create mode 100644 ninjacross-8a77c8ef79a7.json
 create mode 100644 package-lock.json
 create mode 100644 package.json
 create mode 100644 pentest/enumerate.py
 create mode 100644 pentest/realistic_enumeration.py
 create mode 100644 public/404.html
 create mode 100644 public/admin-dashboard.html
 create mode 100644 public/adminlogin.html
 create mode 100644 public/agb.html
 create mode 100644 public/css/admin-dashboard.css
 create mode 100644 public/css/adminlogin.css
 create mode 100644 public/css/dashboard.css
 create mode 100644 public/css/generator.css
 create mode 100644 public/css/index.css
 create mode 100644 public/css/login.css
 create mode 100644 public/css/reset-password.css
 create mode 100644 public/dashboard.html
 create mode 100644 public/datenschutz.html
 create mode 100644 public/email-templates/EMAIL-COMPATIBILITY-GUIDE.md
 create mode 100644 public/email-templates/README.md
 create mode 100644 public/email-templates/TEMPLATES-OVERVIEW.md
 create mode 100644 public/email-templates/URL-CONFIGURATION-GUIDE.md
 create mode 100644 public/email-templates/change-email.html
 create mode 100644 public/email-templates/change-email.txt
 create mode 100644 public/email-templates/invite-user.html
 create mode 100644 public/email-templates/invite-user.txt
 create mode 100644 public/email-templates/magic-link.html
 create mode 100644 public/email-templates/magic-link.txt
 create mode 100644 public/email-templates/reauthentication.html
 create mode 100644 public/email-templates/reauthentication.txt
 create mode 100644 public/email-templates/reset-password-compatible.html
 create mode 100644 public/email-templates/reset-password-optimized.html
 create mode 100644 public/email-templates/reset-password-table.html
 create mode 100644 public/email-templates/reset-password.html
 create mode 100644 public/email-templates/reset-password.txt
 create mode 100644 public/email-templates/welcome-email-compatible.html
 create mode 100644 public/email-templates/welcome-email-simple.html
 create mode 100644 public/email-templates/welcome-email.html
 create mode 100644 public/email-templates/welcome-email.txt
 create mode 100644 public/generator.html
 create mode 100644 public/impressum.html
 create mode 100644 public/index.html
 create mode 100644 public/js/admin-dashboard.js
 create mode 100644 public/js/adminlogin.js
 create mode 100644 public/js/cookie-consent.js
 create mode 100644 public/js/cookie-utils.js
 create mode 100644 public/js/dashboard.js
 create mode 100644 public/js/generator.js
 create mode 100644 public/js/index.js
 create mode 100644 public/js/login.js
 create mode 100644 public/js/page-tracking.js
 create mode 100644 public/js/reset-password.js
 create mode 100644 public/login.html
 create mode 100644 public/manifest.json
 create mode 100644 public/pictures/favicon.ico
 create mode 100644 public/pictures/icon-192.png
 create mode 100644 public/reset-password.html
 create mode 100644 public/sw.js
 create mode 100644 public/test-push.html
 create mode 100644 routes/api.js
 create mode 100644 routes/public.js
 create mode 100644 scripts/best_time_achievements.js
 create mode 100644 scripts/best_time_notifications.js
 create mode 100644 scripts/create-user.js
 create mode 100644 scripts/daily_achievements.js
 create mode 100644 scripts/enhanced_player_notifications.js
 create mode 100644 scripts/fix_player_subscriptions.js
 create mode 100644 scripts/init-db.js
 create mode 100644 scripts/iphone_notifications.js
 create mode 100644 scripts/setup-players.js
 create mode 100644 scripts/setup_cron.js
 create mode 100644 scripts/simulate-new-time.js
 create mode 100644 scripts/test-achievements.js
 create mode 100644 scripts/test-immediate-achievements.js
 create mode 100644 scripts/test-multiple-achievements.js
 create mode 100644 server.js
 create mode 100644 ssl-setup-guide.md
 create mode 100644 swagger.js
 create mode 100644 test-achievements.js
 create mode 100644 wiki/API-Referenz.md
 create mode 100644 wiki/Achievement-System.md
 create mode 100644 wiki/Benutzerhandbuch.md
 create mode 100644 wiki/Datenbank.md
 create mode 100644 wiki/Deployment.md
 create mode 100644 wiki/Entwicklerhandbuch.md
 create mode 100644 wiki/FAQ.md
 create mode 100644 wiki/Home.md
 create mode 100644 wiki/Schnellstart.md
 create mode 100644 wiki/Sicherheit.md
 create mode 100644 wiki/Troubleshooting.md

diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..4c49bd7
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1 @@
+.env
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..23ca8b6
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,107 @@
+# Dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Logs
+logs
+*.log
+server.log
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage directory used by tools like istanbul
+coverage/
+
+# nyc test coverage
+.nyc_output
+
+# Dependency directories
+jspm_packages/
+
+# Optional npm cache directory
+.npm
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# next.js build output
+.next
+
+# nuxt.js build output
+.nuxt
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# MCP Servers (separate repositories)
+gitea-mcp/
+gcp-mcp/
+
+# SSL certificates
+*.pem
+*.key
+*.crt
+
+# Database files
+*.db
+*.sqlite
+
+# Temporary files
+tmp/
+temp/
+
+.pgpass
\ No newline at end of file
diff --git a/ACHIEVEMENTS.md b/ACHIEVEMENTS.md
new file mode 100644
index 0000000..2c812c4
--- /dev/null
+++ b/ACHIEVEMENTS.md
@@ -0,0 +1,217 @@
+# 🏆 Ninja Cross Parkour Achievement System
+
+Ein umfassendes Achievement-System für das Ninja Cross Parkour im Schwimmbad.
+
+## 📊 System-Übersicht
+
+Das Achievement-System besteht aus:
+- **32 verschiedene Achievements** in 4 Kategorien
+- **Automatische tägliche Vergabe** am Ende des Tages
+- **REST API Endpoints** für Frontend-Integration
+- **PostgreSQL Funktionen** für effiziente Verarbeitung
+
+## 🎯 Achievement-Kategorien
+
+### 1. Konsistenz-basierte Achievements
+- **Erste Schritte** 👶 - Erste Zeit aufgezeichnet (5 Punkte)
+- **Durchhalter** 💪 - 3 Versuche an einem Tag (10 Punkte)
+- **Fleißig** 🔥 - 5 Versuche an einem Tag (15 Punkte)
+- **Besessen** 😤 - 10 Versuche an einem Tag (25 Punkte)
+- **Regelmäßig** 📅 - 5 verschiedene Tage gespielt (20 Punkte)
+- **Stammgast** ⭐ - 10 verschiedene Tage gespielt (30 Punkte)
+- **Treue** 💎 - 20 verschiedene Tage gespielt (50 Punkte)
+- **Veteran** 🏆 - 50 verschiedene Tage gespielt (100 Punkte)
+
+### 2. Verbesserungs-basierte Achievements
+- **Fortschritt** 📈 - Persönliche Bestzeit um 5 Sekunden verbessert (15 Punkte)
+- **Durchbruch** ⚡ - Persönliche Bestzeit um 10 Sekunden verbessert (25 Punkte)
+- **Transformation** 🔄 - Persönliche Bestzeit um 15 Sekunden verbessert (40 Punkte)
+- **Perfektionist** ✨ - Persönliche Bestzeit um 20 Sekunden verbessert (60 Punkte)
+
+### 3. Saisonale Achievements
+- **Wochenend-Krieger** 🏁 - Am Wochenende gespielt (10 Punkte)
+- **Nachmittags-Sportler** ☀️ - Zwischen 14-18 Uhr gespielt (10 Punkte)
+- **Frühaufsteher** 🌅 - Vor 10 Uhr gespielt (15 Punkte)
+- **Abend-Sportler** 🌙 - Nach 18 Uhr gespielt (10 Punkte)
+
+### 4. Monatliche Achievements
+- **Januar-Krieger** ❄️ bis **Dezember-Dynamo** 🎄 (je 20 Punkte)
+
+### 5. Jahreszeiten-Achievements
+- **Frühjahrs-Fighter** 🌱 - Im Frühling gespielt (30 Punkte)
+- **Sommer-Sportler** ☀️ - Im Sommer gespielt (30 Punkte)
+- **Herbst-Held** 🍂 - Im Herbst gespielt (30 Punkte)
+- **Winter-Warrior** ❄️ - Im Winter gespielt (30 Punkte)
+
+## 🗄️ Datenbank-Schema
+
+### Tabelle: `achievements`
+```sql
+- id (uuid, PK)
+- name (varchar) - Achievement-Name
+- description (text) - Beschreibung
+- category (varchar) - Kategorie
+- condition_type (varchar) - Bedingungstyp
+- condition_value (integer) - Bedingungswert
+- icon (varchar) - Emoji-Icon
+- points (integer) - Punkte
+- is_active (boolean) - Aktiv
+- created_at (timestamp)
+```
+
+### Tabelle: `player_achievements`
+```sql
+- id (uuid, PK)
+- player_id (uuid, FK) - Verweis auf players.id
+- achievement_id (uuid, FK) - Verweis auf achievements.id
+- earned_at (timestamp) - Wann erreicht
+- progress (integer) - Fortschritt
+- is_completed (boolean) - Abgeschlossen
+- created_at (timestamp)
+```
+
+## 🔧 PostgreSQL Funktionen
+
+### `check_consistency_achievements(player_uuid)`
+Überprüft alle Konsistenz-basierten Achievements für einen Spieler.
+
+### `check_improvement_achievements(player_uuid)`
+Überprüft alle Verbesserungs-basierten Achievements für einen Spieler.
+
+### `check_seasonal_achievements(player_uuid)`
+Überprüft alle saisonalen und monatlichen Achievements für einen Spieler.
+
+### `check_all_achievements(player_uuid)`
+Führt alle Achievement-Überprüfungen für einen Spieler aus.
+
+## 🚀 API Endpoints
+
+### GET `/api/achievements`
+Alle verfügbaren Achievements abrufen.
+
+### GET `/api/achievements/player/:playerId`
+Achievements eines bestimmten Spielers abrufen.
+
+### GET `/api/achievements/player/:playerId/stats`
+Achievement-Statistiken eines Spielers abrufen.
+
+### POST `/api/achievements/check/:playerId`
+Achievements für einen Spieler manuell überprüfen.
+
+### POST `/api/achievements/daily-check`
+Tägliche Achievement-Überprüfung für alle Spieler ausführen.
+
+### GET `/api/achievements/leaderboard?limit=10`
+Bestenliste der Spieler nach Achievement-Punkten.
+
+## 📅 Automatisierung
+
+### Tägliches Script
+```bash
+# Manuell ausführen
+node scripts/daily_achievements.js
+
+# Cron-Job einrichten
+node scripts/setup_cron.js setup
+
+# Cron-Job Status prüfen
+node scripts/setup_cron.js status
+
+# Cron-Job entfernen
+node scripts/setup_cron.js remove
+```
+
+### Cron-Schedule
+- **Zeit**: Täglich um 23:59 Uhr
+- **Log**: `/var/log/ninjaserver_achievements.log`
+
+## 🎮 Frontend-Integration
+
+### Beispiel: Achievement-Liste laden
+```javascript
+fetch('/api/achievements/player/PLAYER_ID')
+  .then(response => response.json())
+  .then(data => {
+    data.data.forEach(achievement => {
+      console.log(`${achievement.icon} ${achievement.name}: ${achievement.is_completed ? '✅' : '❌'}`);
+    });
+  });
+```
+
+### Beispiel: Statistiken anzeigen
+```javascript
+fetch('/api/achievements/player/PLAYER_ID/stats')
+  .then(response => response.json())
+  .then(data => {
+    console.log(`Punkte: ${data.data.total_points}`);
+    console.log(`Abgeschlossen: ${data.data.completed_achievements}/${data.data.total_achievements}`);
+  });
+```
+
+## 🔍 Monitoring
+
+### Logs überwachen
+```bash
+# Live-Logs anzeigen
+tail -f /var/log/ninjaserver_achievements.log
+
+# Letzte Ausführung prüfen
+grep "Daily achievement check completed" /var/log/ninjaserver_achievements.log | tail -1
+```
+
+### Datenbank-Status prüfen
+```sql
+-- Achievement-Statistiken
+SELECT 
+    COUNT(*) as total_achievements,
+    COUNT(CASE WHEN is_active = true THEN 1 END) as active_achievements
+FROM achievements;
+
+-- Spieler-Statistiken
+SELECT 
+    COUNT(DISTINCT player_id) as players_with_achievements,
+    COUNT(*) as total_earned_achievements
+FROM player_achievements 
+WHERE is_completed = true;
+```
+
+## 🛠️ Wartung
+
+### Neue Achievements hinzufügen
+1. Achievement in `achievements` Tabelle einfügen
+2. Logik in entsprechenden PostgreSQL Funktionen erweitern
+3. API Endpoints testen
+
+### Achievement deaktivieren
+```sql
+UPDATE achievements SET is_active = false WHERE name = 'Achievement-Name';
+```
+
+### Daten zurücksetzen
+```sql
+-- Alle Spieler-Achievements löschen
+DELETE FROM player_achievements;
+
+-- Achievement-Statistiken zurücksetzen
+UPDATE achievements SET created_at = NOW();
+```
+
+## 📈 Performance
+
+- **Indizierung**: Automatische Indizes auf `player_id` und `achievement_id`
+- **Batch-Processing**: Effiziente Verarbeitung aller Spieler
+- **Caching**: Achievements werden nur bei Änderungen neu berechnet
+- **Timezone**: Korrekte Zeitzone-Behandlung (Europe/Berlin)
+
+## 🔒 Sicherheit
+
+- **API-Schutz**: Alle Endpoints über bestehende Authentifizierung
+- **SQL-Injection**: Parametrisierte Queries
+- **Datenvalidierung**: Eingabe-Validierung in allen Funktionen
+- **Fehlerbehandlung**: Umfassende Error-Handling
+
+---
+
+**Erstellt am**: $(date)  
+**Version**: 1.0.0  
+**Autor**: Ninja Cross Parkour System
diff --git a/API.md b/API.md
new file mode 100644
index 0000000..477b6c9
--- /dev/null
+++ b/API.md
@@ -0,0 +1,779 @@
+# 🏃‍♂️ Ninja Cross Parkour API Dokumentation
+
+**Version:** 1.0.0  
+**Base URL:** `https://ninja.reptilfpv.de/api`  
+**Beschreibung:** API für das Ninja Cross Parkour System im Schwimmbad
+
+## 📋 Inhaltsverzeichnis
+
+- [🔐 Authentifizierung](#-authentifizierung)
+- [🌐 Public API](#-public-api)
+- [🔒 Private API](#-private-api)
+- [🖥️ Web API](#️-web-api)
+- [👑 Admin API](#-admin-api)
+- [🏆 Achievements API](#-achievements-api)
+- [📊 Datenmodelle](#-datenmodelle)
+- [❌ Fehlerbehandlung](#-fehlerbehandlung)
+
+---
+
+## 🔐 Authentifizierung
+
+### API-Key Authentifizierung
+Für private Endpoints wird ein API-Key im Authorization Header benötigt:
+
+```http
+Authorization: Bearer YOUR_API_KEY_HERE
+```
+
+### Session-basierte Authentifizierung
+Für Web-Endpoints wird eine Session-basierte Authentifizierung verwendet.
+
+### Admin-Authentifizierung
+Für Admin-Endpoints wird eine erweiterte Authentifizierung mit Admin-Rechten benötigt.
+
+---
+
+## 🌐 Public API
+
+Öffentliche Endpoints ohne Authentifizierung.
+
+### 🔑 Authentifizierung
+
+#### Login
+```http
+POST /api/v1/public/login
+Content-Type: application/json
+
+{
+  "username": "admin",
+  "password": "admin123"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Login erfolgreich",
+  "user": {
+    "id": 1,
+    "username": "admin",
+    "is_active": true
+  }
+}
+```
+
+#### Logout
+```http
+POST /api/v1/public/logout
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Logout erfolgreich"
+}
+```
+
+### 👥 Spieler Management
+
+#### Spieler erstellen
+```http
+POST /api/v1/public/players
+Content-Type: application/json
+
+{
+  "firstname": "Max",
+  "lastname": "Mustermann",
+  "birthdate": "1990-01-01",
+  "rfiduid": "AA:BB:CC:DD"
+}
+```
+
+#### Spieler verknüpfen
+```http
+POST /api/v1/public/link-player
+Content-Type: application/json
+
+{
+  "rfiduid": "AA:BB:CC:DD",
+  "supabase_user_id": "uuid-here"
+}
+```
+
+#### Spieler per RFID verknüpfen
+```http
+POST /api/v1/public/link-by-rfid
+Content-Type: application/json
+
+{
+  "rfiduid": "AA:BB:CC:DD",
+  "supabase_user_id": "uuid-here"
+}
+```
+
+### 📍 Standorte
+
+#### Alle Standorte abrufen
+```http
+GET /api/v1/public/locations
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "data": [
+    {
+      "id": "uuid",
+      "name": "Standort 1",
+      "latitude": 48.1351,
+      "longitude": 11.5820,
+      "time_threshold": {
+        "seconds": 120
+      },
+      "created_at": "2024-01-01T00:00:00Z"
+    }
+  ]
+}
+```
+
+### ⏱️ Zeiten
+
+#### Alle Zeiten abrufen
+```http
+GET /api/v1/public/times
+```
+
+#### Zeiten mit Details abrufen
+```http
+GET /api/v1/public/times-with-details
+```
+
+#### Beste Zeiten abrufen
+```http
+GET /api/v1/public/best-times
+```
+
+#### Benutzer-Zeiten abrufen
+```http
+GET /api/v1/public/user-times/{supabase_user_id}
+```
+
+#### Benutzer-Spieler abrufen
+```http
+GET /api/v1/public/user-player/{supabase_user_id}
+```
+
+### 📊 Statistiken
+
+#### Seitenaufruf verfolgen
+```http
+POST /api/v1/public/track-page-view
+Content-Type: application/json
+
+{
+  "page": "/dashboard",
+  "user_agent": "Mozilla/5.0...",
+  "ip_address": "192.168.1.1"
+}
+```
+
+### 🔔 Push Notifications
+
+#### Push-Benachrichtigung abonnieren
+```http
+POST /api/v1/public/subscribe
+Content-Type: application/json
+
+{
+  "endpoint": "https://fcm.googleapis.com/fcm/send/...",
+  "keys": {
+    "p256dh": "key-here",
+    "auth": "auth-key-here"
+  }
+}
+```
+
+#### Push-Benachrichtigung testen
+```http
+POST /api/v1/public/test-push
+Content-Type: application/json
+
+{
+  "title": "Test",
+  "body": "Test-Nachricht",
+  "icon": "/icon.png"
+}
+```
+
+#### Push-Status abrufen
+```http
+GET /api/v1/public/push-status
+```
+
+---
+
+## 🔒 Private API
+
+Private Endpoints mit API-Key Authentifizierung.
+
+### 🎫 Token Management
+
+#### Token speichern
+```http
+POST /api/v1/private/save-token
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "token": "GENERATED_TOKEN",
+  "description": "Beschreibung",
+  "standorte": "München, Berlin"
+}
+```
+
+#### Alle Token abrufen
+```http
+GET /api/v1/private/tokens
+Authorization: Bearer YOUR_API_KEY
+```
+
+#### Token validieren
+```http
+POST /api/v1/private/validate-token
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "token": "TOKEN_TO_VALIDATE"
+}
+```
+
+### 📍 Standort Management
+
+#### Standort erstellen
+```http
+POST /api/v1/private/create-location
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "name": "München",
+  "latitude": 48.1351,
+  "longitude": 11.5820
+}
+```
+
+#### Alle Standorte abrufen
+```http
+GET /api/v1/private/locations
+Authorization: Bearer YOUR_API_KEY
+```
+
+#### Standort-Schwelle aktualisieren
+```http
+PUT /api/v1/private/locations/{id}/threshold
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "threshold_seconds": 120
+}
+```
+
+#### Standorte abrufen (Alternative)
+```http
+GET /api/v1/private/get-locations
+Authorization: Bearer YOUR_API_KEY
+```
+
+### 👥 Spieler Management
+
+#### Spieler erstellen
+```http
+POST /api/v1/private/create-player
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "firstname": "Max",
+  "lastname": "Mustermann",
+  "birthdate": "1990-01-01",
+  "rfiduid": "AA:BB:CC:DD"
+}
+```
+
+#### Benutzer suchen
+```http
+POST /api/v1/private/users/find
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "search_term": "Max"
+}
+```
+
+### ⏱️ Zeit Management
+
+#### Zeit erstellen
+```http
+POST /api/v1/private/create-time
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "player_id": "RFIDUID",
+  "location_id": "Name",
+  "recorded_time": "01:23.456"
+}
+```
+
+---
+
+## 🖥️ Web API
+
+Web-API-Endpoints für das Frontend.
+
+### 🔑 API-Key generieren
+```http
+POST /api/v1/web/generate-api-key
+Content-Type: application/json
+
+{
+  "description": "Mein API Key",
+  "standorte": "München, Berlin"
+}
+```
+
+### 📍 Standort erstellen
+```http
+POST /api/v1/web/create-location
+Content-Type: application/json
+
+{
+  "name": "München",
+  "latitude": 48.1351,
+  "longitude": 11.5820
+}
+```
+
+### 🎫 Token speichern
+```http
+POST /api/v1/web/save-token
+Content-Type: application/json
+
+{
+  "token": "GENERATED_TOKEN",
+  "description": "Beschreibung",
+  "standorte": "München, Berlin"
+}
+```
+
+### 🔍 Session prüfen
+```http
+GET /api/v1/web/check-session
+```
+
+---
+
+## 👑 Admin API
+
+Admin-API-Endpoints für Verwaltung.
+
+### 📊 Statistiken
+
+#### Admin-Statistiken
+```http
+GET /api/v1/admin/stats
+Authorization: Bearer ADMIN_TOKEN
+```
+
+#### Seiten-Statistiken
+```http
+GET /api/v1/admin/page-stats
+Authorization: Bearer ADMIN_TOKEN
+```
+
+### 👥 Spieler Verwaltung
+
+#### Alle Spieler abrufen
+```http
+GET /api/v1/admin/players
+Authorization: Bearer ADMIN_TOKEN
+```
+
+#### Spieler erstellen
+```http
+POST /api/v1/admin/players
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "firstname": "Max",
+  "lastname": "Mustermann",
+  "birthdate": "1990-01-01",
+  "rfiduid": "AA:BB:CC:DD"
+}
+```
+
+#### Spieler aktualisieren
+```http
+PUT /api/v1/admin/players/{id}
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "firstname": "Max",
+  "lastname": "Mustermann",
+  "birthdate": "1990-01-01",
+  "rfiduid": "AA:BB:CC:DD"
+}
+```
+
+#### Spieler löschen
+```http
+DELETE /api/v1/admin/players/{id}
+Authorization: Bearer ADMIN_TOKEN
+```
+
+### 🏃‍♂️ Läufe Verwaltung
+
+#### Alle Läufe abrufen
+```http
+GET /api/v1/admin/runs
+Authorization: Bearer ADMIN_TOKEN
+```
+
+#### Lauf abrufen
+```http
+GET /api/v1/admin/runs/{id}
+Authorization: Bearer ADMIN_TOKEN
+```
+
+#### Lauf erstellen
+```http
+POST /api/v1/admin/runs
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "player_id": "uuid",
+  "location_id": "uuid",
+  "recorded_time": "01:23.456"
+}
+```
+
+#### Lauf aktualisieren
+```http
+PUT /api/v1/admin/runs/{id}
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "recorded_time": "01:20.000"
+}
+```
+
+#### Lauf löschen
+```http
+DELETE /api/v1/admin/runs/{id}
+Authorization: Bearer ADMIN_TOKEN
+```
+
+### 📍 Standort Verwaltung
+
+#### Alle Standorte abrufen
+```http
+GET /api/v1/admin/locations
+Authorization: Bearer ADMIN_TOKEN
+```
+
+#### Standort erstellen
+```http
+POST /api/v1/admin/locations
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "name": "München",
+  "latitude": 48.1351,
+  "longitude": 11.5820,
+  "time_threshold": 120
+}
+```
+
+#### Standort aktualisieren
+```http
+PUT /api/v1/admin/locations/{id}
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "name": "München Updated",
+  "latitude": 48.1351,
+  "longitude": 11.5820,
+  "time_threshold": 120
+}
+```
+
+#### Standort löschen
+```http
+DELETE /api/v1/admin/locations/{id}
+Authorization: Bearer ADMIN_TOKEN
+```
+
+### 👤 Admin-Benutzer Verwaltung
+
+#### Alle Admin-Benutzer abrufen
+```http
+GET /api/v1/admin/adminusers
+Authorization: Bearer ADMIN_TOKEN
+```
+
+#### Admin-Benutzer erstellen
+```http
+POST /api/v1/admin/adminusers
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "username": "newadmin",
+  "password": "securepassword"
+}
+```
+
+#### Admin-Benutzer aktualisieren
+```http
+PUT /api/v1/admin/adminusers/{id}
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "username": "updatedadmin",
+  "is_active": true
+}
+```
+
+#### Admin-Benutzer löschen
+```http
+DELETE /api/v1/admin/adminusers/{id}
+Authorization: Bearer ADMIN_TOKEN
+```
+
+---
+
+## 🏆 Achievements API
+
+Achievement-System Endpoints.
+
+### 🏆 Achievements abrufen
+```http
+GET /api/achievements
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "data": [
+    {
+      "id": "uuid",
+      "name": "Erster Lauf",
+      "description": "Absolviere deinen ersten Lauf",
+      "category": "consistency",
+      "condition_type": "runs_count",
+      "condition_value": 1,
+      "icon": "🏃‍♂️",
+      "points": 10,
+      "is_active": true
+    }
+  ]
+}
+```
+
+### 👤 Spieler-Achievements
+```http
+GET /api/achievements/player/{playerId}
+```
+
+### 📊 Spieler-Statistiken
+```http
+GET /api/achievements/player/{playerId}/stats
+```
+
+### ✅ Achievement prüfen
+```http
+POST /api/achievements/check/{playerId}
+Content-Type: application/json
+
+{
+  "achievement_id": "uuid"
+}
+```
+
+### 📅 Tägliche Prüfung
+```http
+POST /api/achievements/daily-check
+```
+
+### 🏃‍♂️ Beste Zeit prüfen
+```http
+POST /api/achievements/best-time-check
+```
+
+### 🏅 Leaderboard
+```http
+GET /api/achievements/leaderboard
+```
+
+---
+
+## 📊 Datenmodelle
+
+### Player
+```json
+{
+  "id": "string (uuid)",
+  "firstname": "string",
+  "lastname": "string",
+  "birthdate": "string (date)",
+  "rfiduid": "string (XX:XX:XX:XX)",
+  "supabase_user_id": "string (uuid)",
+  "created_at": "string (date-time)"
+}
+```
+
+### Time
+```json
+{
+  "id": "string (uuid)",
+  "player_id": "string (uuid)",
+  "location_id": "string (uuid)",
+  "recorded_time": {
+    "seconds": "number",
+    "minutes": "number",
+    "milliseconds": "number"
+  },
+  "created_at": "string (date-time)"
+}
+```
+
+### Location
+```json
+{
+  "id": "string (uuid)",
+  "name": "string",
+  "latitude": "number (float)",
+  "longitude": "number (float)",
+  "time_threshold": {
+    "seconds": "number",
+    "minutes": "number"
+  },
+  "created_at": "string (date-time)"
+}
+```
+
+### Achievement
+```json
+{
+  "id": "string (uuid)",
+  "name": "string",
+  "description": "string",
+  "category": "string (consistency|improvement|seasonal|monthly)",
+  "condition_type": "string",
+  "condition_value": "integer",
+  "icon": "string (emoji)",
+  "points": "integer",
+  "is_active": "boolean"
+}
+```
+
+### PlayerAchievement
+```json
+{
+  "id": "string (uuid)",
+  "player_id": "string (uuid)",
+  "achievement_id": "string (uuid)",
+  "progress": "integer",
+  "is_completed": "boolean",
+  "earned_at": "string (date-time)"
+}
+```
+
+---
+
+## ❌ Fehlerbehandlung
+
+### Standard-Fehlerantwort
+```json
+{
+  "success": false,
+  "message": "Fehlermeldung",
+  "error": "DETAILED_ERROR_INFO"
+}
+```
+
+### HTTP-Status-Codes
+
+- **200 OK** - Erfolgreiche Anfrage
+- **201 Created** - Ressource erfolgreich erstellt
+- **400 Bad Request** - Ungültige Anfrage
+- **401 Unauthorized** - Nicht authentifiziert
+- **403 Forbidden** - Keine Berechtigung
+- **404 Not Found** - Ressource nicht gefunden
+- **500 Internal Server Error** - Serverfehler
+
+### Häufige Fehlermeldungen
+
+- `"API-Key erforderlich"` - Fehlender oder ungültiger API-Key
+- `"Ungültige Anmeldedaten"` - Falsche Login-Daten
+- `"Ressource nicht gefunden"` - Angeforderte Ressource existiert nicht
+- `"Ungültige Daten"` - Validierungsfehler bei Eingabedaten
+- `"Keine Berechtigung"` - Unzureichende Rechte für die Aktion
+
+---
+
+## 🔧 Entwicklung
+
+### Lokale Entwicklung
+```bash
+# Server starten
+npm run dev
+
+# API-Dokumentation anzeigen
+# Swagger UI verfügbar unter: http://localhost:3000/api-docs
+```
+
+### Produktionsumgebung
+```bash
+# Server starten
+npm start
+
+# API-Dokumentation: https://ninja.reptilfpv.de/api-docs
+```
+
+---
+
+## 📝 Changelog
+
+### Version 1.0.0
+- Initiale API-Implementierung
+- Public, Private, Web und Admin Endpoints
+- Achievement-System
+- Push-Notification Support
+- Swagger-Dokumentation
+
+---
+
+## 👨‍💻 Autor
+
+**Carsten Graf**  
+*Ninja Cross Parkour System*
+
+---
+
+**⚠️ Wichtig:** Ändern Sie die Standardpasswörter in der Produktionsumgebung!
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..5b0a576
--- /dev/null
+++ b/README.md
@@ -0,0 +1,222 @@
+# 🔐 Lizenzgenerator mit PostgreSQL Integration
+
+Ein sicherer Lizenzgenerator mit PostgreSQL-Datenbank, interaktiver Karte und API-Key Authentifizierung.
+
+## ✨ Features
+
+- **🔑 Sichere Lizenzgenerierung** mit HMAC-SHA256
+- **🗄️ PostgreSQL Integration** für lokale Datenspeicherung
+- **🗺️ Interaktive Karte** mit Leaflet.js und OpenStreetMap
+- **🔍 Standortsuche** über Nominatim API
+- **🔐 API-Key Authentifizierung** für alle API-Endpunkte
+- **🌐 Web-Interface** mit Login-Schutz
+- **📱 Responsive Design** für alle Geräte
+
+## 🚀 Installation
+
+### Voraussetzungen
+- Node.js (v16 oder höher)
+- PostgreSQL Datenbank
+- npm oder yarn
+
+### Setup
+```bash
+# Repository klonen
+git clone <repository-url>
+cd ninjaserver
+
+# Abhängigkeiten installieren
+npm install
+
+# Umgebungsvariablen konfigurieren
+cp .env.example .env
+# .env-Datei mit Ihren Datenbankdaten bearbeiten
+
+# Datenbank initialisieren
+npm run init-db
+
+# Server starten
+npm start
+```
+
+
+## 🔐 Authentifizierung
+
+### Web-Interface
+- **Standardanmeldung**: `admin` / `admin123`
+- **Benutzer erstellen**: `npm run create-user`
+
+### API-Key Authentifizierung
+Alle API-Endpunkte erfordern einen gültigen API-Key im `Authorization` Header:
+
+```bash
+Authorization: Bearer YOUR_API_KEY_HERE
+```
+
+#### API-Key generieren
+```bash
+curl -X POST http://localhost:3000/api/generate-api-key \
+  -H "Content-Type: application/json" \
+  -d '{"description": "Mein API Key", "standorte": "München, Berlin"}'
+```
+
+## 📡 API-Endpunkte
+
+### Geschützte Endpunkte (API-Key erforderlich)
+
+#### Standorte abrufen
+```bash
+curl -X GET http://localhost:3000/api/locations \
+  -H "Authorization: Bearer YOUR_API_KEY"
+```
+
+#### Neuen Standort erstellen
+```bash
+curl -X POST http://localhost:3000/api/create-location \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -d '{"name": "München", "lat": 48.1351, "lon": 11.5820}'
+```
+
+#### API-Tokens abrufen
+```bash
+curl -X GET http://localhost:3000/api/tokens \
+  -H "Authorization: Bearer YOUR_API_KEY"
+```
+
+#### Token validieren
+```bash
+curl -X POST http://localhost:3000/api/validate-token \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -d '{"token": "TOKEN_TO_VALIDATE"}'
+```
+
+#### Token speichern
+```bash
+curl -X POST http://localhost:3000/api/save-token \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -d '{"token": "GENERATED_TOKEN", "description": "Beschreibung", "standorte": "Standorte"}'
+```
+
+### Öffentliche Endpunkte (nur Web-Interface)
+
+#### Login
+```bash
+curl -X POST http://localhost:3000/api/login \
+  -H "Content-Type: application/json" \
+  -d '{"username": "admin", "password": "admin123"}'
+```
+
+#### Logout
+```bash
+curl -X POST http://localhost:3000/api/logout
+```
+
+## 🗄️ Datenbankstruktur
+
+### `adminusers` Tabelle
+```sql
+CREATE TABLE adminusers (
+    id SERIAL PRIMARY KEY,
+    username VARCHAR(50) UNIQUE NOT NULL,
+    password_hash VARCHAR(255) NOT NULL,
+    is_active BOOLEAN DEFAULT true,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    last_login TIMESTAMP
+);
+```
+
+### `api_tokens` Tabelle
+```sql
+CREATE TABLE api_tokens (
+    id SERIAL PRIMARY KEY,
+    token VARCHAR(255) UNIQUE NOT NULL,
+    description TEXT,
+    standorte TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    expires_at TIMESTAMP,
+    is_active BOOLEAN DEFAULT true
+);
+```
+
+### `locations` Tabelle
+```sql
+CREATE TABLE locations (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(255) UNIQUE NOT NULL,
+    latitude DECIMAL(10, 8) NOT NULL,
+    longitude DECIMAL(11, 8) NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+## 🧪 API testen
+
+### Test-Skript verwenden
+```bash
+# test-api.js bearbeiten und API_KEY setzen
+node test-api.js
+```
+
+### Manueller Test
+```bash
+# 1. API-Key generieren
+curl -X POST http://localhost:3000/api/generate-api-key \
+  -H "Content-Type: application/json" \
+  -d '{"description": "Test Key"}'
+
+# 2. API mit generiertem Key testen
+curl -X GET http://localhost:3000/api/locations \
+  -H "Authorization: Bearer GENERATED_API_KEY"
+```
+
+## 📁 Projektstruktur
+
+```
+ninjaserver/
+├── server.js              # Hauptserver-Datei
+├── routes/
+│   └── api.js            # API-Routen mit Bearer Token Auth
+├── scripts/
+│   ├── init-db.js        # Datenbankinitialisierung
+│   └── create-user.js    # Benutzer-Erstellung
+├── public/
+│   ├── index.html        # Hauptanwendung
+│   └── login.html        # Login-Seite
+├── test-api.js           # API-Test-Skript
+└── package.json
+```
+
+## 🚀 Deployment
+
+### Lokale Entwicklung
+```bash
+npm run dev  # Mit Nodemon für automatisches Neuladen
+```
+
+### Produktion
+```bash
+npm start    # Produktionsserver
+```
+
+## 🔒 Sicherheit
+
+- **API-Key Authentifizierung** für alle API-Endpunkte
+- **Session-basierte Authentifizierung** für Web-Interface
+- **Passwort-Hashing** mit bcrypt
+- **HTTPS empfohlen** für Produktionsumgebung
+- **Regelmäßige API-Key Rotation** empfohlen
+
+## 📝 Lizenz
+
+Proprietär - Alle Rechte vorbehalten
+
+## 👨‍💻 Autor
+
+Carsten Graf
+
+---
+
+**⚠️ Wichtig**: Ändern Sie die Standardpasswörter in der Produktionsumgebung!
diff --git a/apache-ssl-config.conf b/apache-ssl-config.conf
new file mode 100644
index 0000000..ccaa5dc
--- /dev/null
+++ b/apache-ssl-config.conf
@@ -0,0 +1,51 @@
+# Apache SSL VirtualHost für NinjaCross
+# Datei: /etc/apache2/sites-available/ninjaserver-ssl.conf
+
+<VirtualHost *:443>
+    ServerName ninja.reptilfpv.de
+    DocumentRoot /var/www/html
+    
+    # SSL Configuration
+    SSLEngine on
+    SSLCertificateFile /etc/letsencrypt/live/ninja.reptilfpv.de/fullchain.pem
+    SSLCertificateKeyFile /etc/letsencrypt/live/ninja.reptilfpv.de/privkey.pem
+    
+    # Security Headers für Kamera-Zugriff
+    Header always set Strict-Transport-Security "max-age=63072000; includeSubDomains; preload"
+    Header always set X-Content-Type-Options nosniff
+    Header always set X-Frame-Options DENY
+    Header always set Referrer-Policy strict-origin-when-cross-origin
+    
+    # Wichtig für Kamera-Zugriff
+    Header always set Permissions-Policy "camera=self, microphone=()"
+    
+    # WebSocket Support - MUSS vor dem generellen Proxy stehen
+    RewriteEngine On
+    RewriteCond %{HTTP:Upgrade} websocket [NC]
+    RewriteCond %{HTTP:Connection} upgrade [NC]
+    RewriteRule ^/?(.*) "ws://localhost:3000/$1" [P,L]
+    
+    # Socket.IO spezifische WebSocket-Routen
+    ProxyPass /socket.io/ ws://localhost:3000/socket.io/
+    ProxyPassReverse /socket.io/ ws://localhost:3000/socket.io/
+    
+    # Standard HTTP/HTTPS Reverse Proxy zu Node.js
+    ProxyPreserveHost On
+    ProxyPass /socket.io/ !
+    ProxyPass / http://localhost:3000/
+    ProxyPassReverse / http://localhost:3000/
+    
+    # WebSocket Proxy-Einstellungen
+    ProxyTimeout 3600
+    ProxyBadHeader Ignore
+    
+    # Logging
+    ErrorLog ${APACHE_LOG_DIR}/ninjaserver_ssl_error.log
+    CustomLog ${APACHE_LOG_DIR}/ninjaserver_ssl_access.log combined
+</VirtualHost>
+
+# HTTP zu HTTPS Redirect
+<VirtualHost *:80>
+    ServerName ninja.reptilfpv.de
+    Redirect permanent / https://ninja.reptilfpv.de/
+</VirtualHost>
diff --git a/config/blacklist-db.js b/config/blacklist-db.js
new file mode 100644
index 0000000..32146da
--- /dev/null
+++ b/config/blacklist-db.js
@@ -0,0 +1,335 @@
+/**
+ * Datenbankbasierte Blacklist für unerwünschte Namen
+ * Lädt und verwaltet Blacklist-Einträge aus der Datenbank
+ */
+
+const { checkWithCategoryThreshold, checkWithTrigramIndex, TrigramIndex, THRESHOLDS } = require('./levenshtein');
+
+// Datenbankverbindung direkt hier implementieren
+const { Pool } = require('pg');
+
+const pool = new Pool({
+    user: process.env.DB_USER || 'postgres',
+    host: process.env.DB_HOST || 'localhost',
+    database: process.env.DB_NAME || 'ninjaserver',
+    password: process.env.DB_PASSWORD || 'password',
+    port: process.env.DB_PORT || 5432,
+});
+
+// Trigram-Index für Performance-Optimierung
+let trigramIndex = null;
+let blacklistCache = null;
+let lastCacheUpdate = 0;
+const CACHE_TTL = 5 * 60 * 1000; // 5 Minuten
+
+/**
+ * Lädt alle Blacklist-Einträge aus der Datenbank mit Caching
+ * @returns {Object} - Blacklist gruppiert nach Kategorien
+ */
+async function loadBlacklistFromDB() {
+    const now = Date.now();
+
+    // Verwende Cache falls verfügbar und nicht abgelaufen
+    if (blacklistCache && (now - lastCacheUpdate) < CACHE_TTL) {
+        return blacklistCache;
+    }
+
+    try {
+        const result = await pool.query(
+            'SELECT term, category FROM blacklist_terms ORDER BY category, term'
+        );
+
+        const blacklist = {
+            historical: [],
+            offensive: [],
+            titles: [],
+            brands: [],
+            inappropriate: [],
+            racial: [],
+            religious: [],
+            disability: [],
+            leetspeak: [],
+            cyberbullying: [],
+            drugs: [],
+            violence: []
+        };
+
+        // Erstelle neuen Trigram-Index
+        trigramIndex = new TrigramIndex();
+
+        result.rows.forEach(row => {
+            if (blacklist[row.category]) {
+                blacklist[row.category].push(row.term);
+                // Füge zum Trigram-Index hinzu
+                trigramIndex.addTerm(row.term, row.category);
+            }
+        });
+
+        // Cache aktualisieren
+        blacklistCache = blacklist;
+        lastCacheUpdate = now;
+
+        return blacklist;
+    } catch (error) {
+        console.error('Error loading blacklist from database:', error);
+        // Fallback zur statischen Blacklist
+        return getStaticBlacklist();
+    }
+}
+
+/**
+ * Statische Blacklist als Fallback
+ */
+function getStaticBlacklist() {
+    return {
+        historical: [
+            'adolf', 'hitler', 'adolf hitler', 'adolfhittler',
+            'mussolini', 'benito', 'benito mussolini',
+            'stalin', 'joseph stalin', 'mao', 'mao zedong'
+        ],
+        offensive: [
+            'satan', 'luzifer', 'teufel', 'devil',
+            'hurensohn', 'wichser', 'fotze', 'arschloch',
+            'idiot', 'dummkopf', 'trottel', 'schwachsinnig',
+            'nazi', 'faschist', 'rassist'
+        ],
+        titles: [
+            'lord', 'lady', 'sir', 'dame',
+            'prinz', 'prinzessin', 'prince', 'princess',
+            'könig', 'königin', 'king', 'queen',
+            'doktor', 'professor', 'dr', 'prof'
+        ],
+        brands: [
+            'mcdonald', 'coca cola', 'cocacola', 'pepsi',
+            'nike', 'adidas', 'puma', 'reebok',
+            'bmw', 'mercedes', 'audi', 'volkswagen'
+        ],
+        inappropriate: [
+            'sex', 'porn', 'porno', 'fuck', 'shit',
+            'bitch', 'whore', 'prostitute',
+            'drug', 'cocaine', 'heroin', 'marijuana'
+        ],
+        racial: [],
+        religious: [],
+        disability: [],
+        leetspeak: [],
+        cyberbullying: [],
+        drugs: [],
+        violence: []
+    };
+}
+
+/**
+ * Prüft ob ein Name in der Blacklist steht (exakte Übereinstimmung)
+ * @param {string} firstname - Vorname
+ * @param {string} lastname - Nachname
+ * @returns {Object} - {isBlocked: boolean, reason: string, category: string}
+ */
+async function checkNameAgainstBlacklist(firstname, lastname) {
+    if (!firstname || !lastname) {
+        return { isBlocked: false, reason: '', category: '' };
+    }
+
+    try {
+        const blacklist = await loadBlacklistFromDB();
+        const fullName = `${firstname.toLowerCase()} ${lastname.toLowerCase()}`;
+        const firstNameOnly = firstname.toLowerCase();
+        const lastNameOnly = lastname.toLowerCase();
+
+        // Alle Blacklist-Einträge in einem Array sammeln
+        const allBlacklistEntries = [];
+
+        Object.entries(blacklist).forEach(([category, entries]) => {
+            entries.forEach(entry => {
+                allBlacklistEntries.push({
+                    term: entry,
+                    category: category,
+                    reason: getCategoryReason(category)
+                });
+            });
+        });
+
+        // 1. Exakte Übereinstimmung prüfen
+        for (const entry of allBlacklistEntries) {
+            const term = entry.term.toLowerCase();
+
+            // Vollständiger Name
+            if (fullName.includes(term) || term.includes(fullName)) {
+                return {
+                    isBlocked: true,
+                    reason: entry.reason,
+                    category: entry.category,
+                    matchedTerm: entry.term,
+                    matchType: 'exact'
+                };
+            }
+
+            // Vorname allein
+            if (firstNameOnly.includes(term) || term.includes(firstNameOnly)) {
+                return {
+                    isBlocked: true,
+                    reason: entry.reason,
+                    category: entry.category,
+                    matchedTerm: entry.term,
+                    matchType: 'exact'
+                };
+            }
+
+            // Nachname allein
+            if (lastNameOnly.includes(term) || term.includes(lastNameOnly)) {
+                return {
+                    isBlocked: true,
+                    reason: entry.reason,
+                    category: entry.category,
+                    matchedTerm: entry.term,
+                    matchType: 'exact'
+                };
+            }
+        }
+
+        // 2. Levenshtein-Distanz prüfen (Fuzzy-Matching)
+        // Verwende Trigram-Index für bessere Performance bei großen Blacklists
+        let levenshteinResult;
+        if (trigramIndex && Object.values(blacklist).flat().length > 100) {
+            // Performance-optimierte Version für große Blacklists
+            levenshteinResult = checkWithTrigramIndex(firstname, lastname, blacklist, trigramIndex);
+        } else {
+            // Standard-Version für kleine Blacklists
+            for (const [category, entries] of Object.entries(blacklist)) {
+                const categoryResult = checkWithCategoryThreshold(firstname, lastname, entries, category);
+                if (categoryResult.hasSimilarTerms) {
+                    levenshteinResult = categoryResult;
+                    break; // Frühe Beendigung bei erstem Match
+                }
+            }
+        }
+
+        if (levenshteinResult && levenshteinResult.hasSimilarTerms) {
+            const bestMatch = levenshteinResult.bestMatch;
+            return {
+                isBlocked: true,
+                reason: `${getCategoryReason(bestMatch.category || 'unknown')} (ähnlich)`,
+                category: bestMatch.category || 'unknown',
+                matchedTerm: bestMatch.term,
+                matchType: 'similar',
+                similarity: bestMatch.distance,
+                levenshteinDistance: bestMatch.levenshteinDistance
+            };
+        }
+
+        return { isBlocked: false, reason: '', category: '' };
+    } catch (error) {
+        console.error('Error checking name against blacklist:', error);
+        return { isBlocked: false, reason: '', category: '' };
+    }
+}
+
+/**
+ * Gibt eine benutzerfreundliche Begründung für die Kategorie zurück
+ */
+function getCategoryReason(category) {
+    const reasons = {
+        historical: 'Historisch belasteter Name',
+        offensive: 'Beleidigender oder anstößiger Begriff',
+        titles: 'Titel oder Berufsbezeichnung',
+        brands: 'Markenname',
+        inappropriate: 'Unpassender Begriff',
+        racial: 'Rassistischer oder ethnisch beleidigender Begriff',
+        religious: 'Religiös beleidigender oder blasphemischer Begriff',
+        disability: 'Beleidigender Begriff bezüglich Behinderungen',
+        leetspeak: 'Verschleierter beleidigender Begriff',
+        cyberbullying: 'Cyberbullying oder Online-Belästigung',
+        drugs: 'Drogenbezogener Begriff',
+        violence: 'Gewalt- oder bedrohungsbezogener Begriff'
+    };
+
+    return reasons[category] || 'Unzulässiger Begriff';
+}
+
+/**
+ * Fügt einen neuen Begriff zur Blacklist hinzu
+ * @param {string} term - Der hinzuzufügende Begriff
+ * @param {string} category - Die Kategorie
+ * @param {string} createdBy - Wer hat den Begriff hinzugefügt
+ */
+async function addToBlacklist(term, category, createdBy = 'admin') {
+    try {
+        await pool.query(
+            'INSERT INTO blacklist_terms (term, category, created_by) VALUES ($1, $2, $3) ON CONFLICT (term, category) DO NOTHING',
+            [term.toLowerCase(), category, createdBy]
+        );
+
+        // Cache invalidieren
+        invalidateCache();
+
+        return true;
+    } catch (error) {
+        console.error('Error adding to blacklist:', error);
+        throw error;
+    }
+}
+
+/**
+ * Entfernt einen Begriff aus der Blacklist
+ * @param {string} term - Der zu entfernende Begriff
+ * @param {string} category - Die Kategorie
+ */
+async function removeFromBlacklist(term, category) {
+    try {
+        const result = await pool.query(
+            'DELETE FROM blacklist_terms WHERE term = $1 AND category = $2',
+            [term.toLowerCase(), category]
+        );
+
+        // Cache invalidieren
+        invalidateCache();
+
+        return result.rowCount > 0;
+    } catch (error) {
+        console.error('Error removing from blacklist:', error);
+        throw error;
+    }
+}
+
+/**
+ * Invalidiert den Blacklist-Cache
+ */
+function invalidateCache() {
+    blacklistCache = null;
+    trigramIndex = null;
+    lastCacheUpdate = 0;
+}
+
+/**
+ * Gibt die komplette Blacklist zurück (für Admin-Zwecke)
+ */
+async function getBlacklist() {
+    return await loadBlacklistFromDB();
+}
+
+/**
+ * Synchronisiert die statische Blacklist mit der Datenbank
+ * (Nur für Initial-Setup oder Migration)
+ */
+async function syncStaticBlacklist() {
+    const staticBlacklist = getStaticBlacklist();
+
+    for (const [category, terms] of Object.entries(staticBlacklist)) {
+        for (const term of terms) {
+            try {
+                await addToBlacklist(term, category, 'system');
+            } catch (error) {
+                console.error(`Error syncing term ${term} in category ${category}:`, error);
+            }
+        }
+    }
+}
+
+module.exports = {
+    checkNameAgainstBlacklist,
+    addToBlacklist,
+    removeFromBlacklist,
+    getBlacklist,
+    loadBlacklistFromDB,
+    syncStaticBlacklist
+};
diff --git a/config/blacklist.js b/config/blacklist.js
new file mode 100644
index 0000000..3e3de56
--- /dev/null
+++ b/config/blacklist.js
@@ -0,0 +1,176 @@
+/**
+ * Blacklist für unerwünschte Namen
+ * Basierend auf deutschen Namensregeln und allgemeinen Richtlinien
+ */
+
+const BLACKLIST = {
+    // Historisch belastete Namen
+    historical: [
+        'adolf', 'hitler', 'adolf hitler', 'adolfhittler', 'adolfhittler',
+        'mussolini', 'benito', 'benito mussolini',
+        'stalin', 'joseph stalin',
+        'mao', 'mao zedong',
+        'pol pot', 'polpot',
+        'saddam', 'saddam hussein',
+        'osama', 'osama bin laden',
+        'kim jong', 'kim jong il', 'kim jong un'
+    ],
+
+    // Beleidigende/anstößige Begriffe
+    offensive: [
+        'satan', 'luzifer', 'teufel', 'devil',
+        'hurensohn', 'wichser', 'fotze', 'arschloch',
+        'idiot', 'dummkopf', 'trottel', 'schwachsinnig',
+        'nazi', 'faschist', 'rassist',
+        'terrorist', 'mörder', 'killer'
+    ],
+
+    // Titel und Berufsbezeichnungen
+    titles: [
+        'lord', 'lady', 'sir', 'dame',
+        'prinz', 'prinzessin', 'prince', 'princess',
+        'könig', 'königin', 'king', 'queen',
+        'kaiser', 'kaiserin', 'emperor', 'empress',
+        'doktor', 'professor', 'dr', 'prof',
+        'pastor', 'pfarrer', 'bischof', 'priester',
+        'richter', 'anwalt', 'notar'
+    ],
+
+    // Markennamen (Beispiele)
+    brands: [
+        'mcdonald', 'coca cola', 'cocacola', 'pepsi',
+        'nike', 'adidas', 'puma', 'reebok',
+        'bmw', 'mercedes', 'audi', 'volkswagen',
+        'apple', 'microsoft', 'google', 'facebook',
+        'samsung', 'sony', 'panasonic'
+    ],
+
+    // Unpassende Begriffe
+    inappropriate: [
+        'sex', 'porn', 'porno', 'fuck', 'shit',
+        'bitch', 'whore', 'prostitute',
+        'drug', 'cocaine', 'heroin', 'marijuana',
+        'bomb', 'explosive', 'weapon', 'gun'
+    ]
+};
+
+/**
+ * Prüft ob ein Name in der Blacklist steht
+ * @param {string} firstname - Vorname
+ * @param {string} lastname - Nachname
+ * @returns {Object} - {isBlocked: boolean, reason: string, category: string}
+ */
+function checkNameAgainstBlacklist(firstname, lastname) {
+    if (!firstname || !lastname) {
+        return { isBlocked: false, reason: '', category: '' };
+    }
+
+    const fullName = `${firstname.toLowerCase()} ${lastname.toLowerCase()}`;
+    const firstNameOnly = firstname.toLowerCase();
+    const lastNameOnly = lastname.toLowerCase();
+
+    // Alle Blacklist-Einträge in einem Array sammeln
+    const allBlacklistEntries = [];
+
+    Object.entries(BLACKLIST).forEach(([category, entries]) => {
+        entries.forEach(entry => {
+            allBlacklistEntries.push({
+                term: entry,
+                category: category,
+                reason: getCategoryReason(category)
+            });
+        });
+    });
+
+    // Prüfung durchführen
+    for (const entry of allBlacklistEntries) {
+        const term = entry.term.toLowerCase();
+
+        // Vollständiger Name
+        if (fullName.includes(term) || term.includes(fullName)) {
+            return {
+                isBlocked: true,
+                reason: entry.reason,
+                category: entry.category,
+                matchedTerm: entry.term
+            };
+        }
+
+        // Vorname allein
+        if (firstNameOnly.includes(term) || term.includes(firstNameOnly)) {
+            return {
+                isBlocked: true,
+                reason: entry.reason,
+                category: entry.category,
+                matchedTerm: entry.term
+            };
+        }
+
+        // Nachname allein
+        if (lastNameOnly.includes(term) || term.includes(lastNameOnly)) {
+            return {
+                isBlocked: true,
+                reason: entry.reason,
+                category: entry.category,
+                matchedTerm: entry.term
+            };
+        }
+    }
+
+    return { isBlocked: false, reason: '', category: '' };
+}
+
+/**
+ * Gibt eine benutzerfreundliche Begründung für die Kategorie zurück
+ */
+function getCategoryReason(category) {
+    const reasons = {
+        historical: 'Historisch belasteter Name',
+        offensive: 'Beleidigender oder anstößiger Begriff',
+        titles: 'Titel oder Berufsbezeichnung',
+        brands: 'Markenname',
+        inappropriate: 'Unpassender Begriff'
+    };
+
+    return reasons[category] || 'Unzulässiger Begriff';
+}
+
+/**
+ * Fügt einen neuen Begriff zur Blacklist hinzu
+ * @param {string} term - Der hinzuzufügende Begriff
+ * @param {string} category - Die Kategorie
+ */
+function addToBlacklist(term, category) {
+    if (BLACKLIST[category] && !BLACKLIST[category].includes(term.toLowerCase())) {
+        BLACKLIST[category].push(term.toLowerCase());
+    }
+}
+
+/**
+ * Entfernt einen Begriff aus der Blacklist
+ * @param {string} term - Der zu entfernende Begriff
+ * @param {string} category - Die Kategorie
+ */
+function removeFromBlacklist(term, category) {
+    if (BLACKLIST[category]) {
+        const index = BLACKLIST[category].indexOf(term.toLowerCase());
+        if (index > -1) {
+            BLACKLIST[category].splice(index, 1);
+        }
+    }
+}
+
+/**
+ * Gibt die komplette Blacklist zurück (für Admin-Zwecke)
+ */
+function getBlacklist() {
+    return BLACKLIST;
+}
+
+module.exports = {
+    checkNameAgainstBlacklist,
+    addToBlacklist,
+    removeFromBlacklist,
+    getBlacklist,
+    BLACKLIST
+};
diff --git a/config/levenshtein.js b/config/levenshtein.js
new file mode 100644
index 0000000..ab0e318
--- /dev/null
+++ b/config/levenshtein.js
@@ -0,0 +1,336 @@
+/**
+ * Levenshtein-Distanz Algorithmus für Fuzzy-Matching
+ * Erkennt Abwandlungen und Tippfehler von Blacklist-Begriffen
+ */
+
+/**
+ * Berechnet die Levenshtein-Distanz zwischen zwei Strings
+ * @param {string} str1 - Erster String
+ * @param {string} str2 - Zweiter String
+ * @returns {number} - Distanz (0 = identisch, höher = unterschiedlicher)
+ */
+function levenshteinDistance(str1, str2) {
+    const len1 = str1.length;
+    const len2 = str2.length;
+
+    // Erstelle Matrix
+    const matrix = Array(len2 + 1).fill(null).map(() => Array(len1 + 1).fill(null));
+
+    // Initialisiere erste Zeile und Spalte
+    for (let i = 0; i <= len1; i++) {
+        matrix[0][i] = i;
+    }
+    for (let j = 0; j <= len2; j++) {
+        matrix[j][0] = j;
+    }
+
+    // Fülle Matrix
+    for (let j = 1; j <= len2; j++) {
+        for (let i = 1; i <= len1; i++) {
+            const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+            matrix[j][i] = Math.min(
+                matrix[j][i - 1] + 1,      // Deletion
+                matrix[j - 1][i] + 1,      // Insertion
+                matrix[j - 1][i - 1] + cost // Substitution
+            );
+        }
+    }
+
+    return matrix[len2][len1];
+}
+
+/**
+ * Berechnet die normalisierte Levenshtein-Distanz (0-1)
+ * @param {string} str1 - Erster String
+ * @param {string} str2 - Zweiter String
+ * @returns {number} - Normalisierte Distanz (0 = identisch, 1 = komplett unterschiedlich)
+ */
+function normalizedLevenshteinDistance(str1, str2) {
+    const distance = levenshteinDistance(str1, str2);
+    const maxLength = Math.max(str1.length, str2.length);
+    return maxLength === 0 ? 0 : distance / maxLength;
+}
+
+/**
+ * Prüft ob ein String ähnlich zu einem Blacklist-Begriff ist
+ * @param {string} input - Eingabe-String
+ * @param {string} blacklistTerm - Blacklist-Begriff
+ * @param {number} threshold - Schwellenwert (0-1, niedriger = strenger)
+ * @returns {boolean} - True wenn ähnlich genug
+ */
+function isSimilarToBlacklistTerm(input, blacklistTerm, threshold = 0.3) {
+    const normalizedDistance = normalizedLevenshteinDistance(input, blacklistTerm);
+    return normalizedDistance <= threshold;
+}
+
+/**
+ * Findet ähnliche Begriffe in einer Blacklist
+ * @param {string} input - Eingabe-String
+ * @param {Array} blacklistTerms - Array von Blacklist-Begriffen
+ * @param {number} threshold - Schwellenwert (0-1)
+ * @returns {Array} - Array von ähnlichen Begriffen mit Distanz
+ */
+function findSimilarTerms(input, blacklistTerms, threshold = 0.3) {
+    const similarTerms = [];
+    const normalizedInput = input.toLowerCase().trim();
+
+    // Performance-Optimierung: Frühe Beendigung bei sehr kurzen Strings
+    if (normalizedInput.length < 2) {
+        return similarTerms;
+    }
+
+    for (const term of blacklistTerms) {
+        const normalizedTerm = term.toLowerCase().trim();
+
+        // Performance-Optimierung: Skip bei zu großer Längendifferenz
+        const lengthDiff = Math.abs(normalizedInput.length - normalizedTerm.length);
+        const maxLengthDiff = Math.ceil(normalizedInput.length * threshold);
+        if (lengthDiff > maxLengthDiff) {
+            continue;
+        }
+
+        const distance = normalizedLevenshteinDistance(normalizedInput, normalizedTerm);
+        if (distance <= threshold) {
+            similarTerms.push({
+                term: term,
+                distance: distance,
+                levenshteinDistance: levenshteinDistance(normalizedInput, normalizedTerm)
+            });
+        }
+    }
+
+    // Sortiere nach Distanz (niedrigste zuerst)
+    return similarTerms.sort((a, b) => a.distance - b.distance);
+}
+
+/**
+ * Erweiterte Blacklist-Prüfung mit Levenshtein-Distanz und Teilstring-Matching
+ * @param {string} firstname - Vorname
+ * @param {string} lastname - Nachname
+ * @param {Array} blacklistTerms - Array von Blacklist-Begriffen
+ * @param {number} threshold - Schwellenwert für Ähnlichkeit (0-1)
+ * @returns {Object} - Prüfungsergebnis mit ähnlichen Begriffen
+ */
+function checkWithLevenshtein(firstname, lastname, blacklistTerms, threshold = 0.3) {
+    const fullName = `${firstname.toLowerCase().trim()} ${lastname.toLowerCase().trim()}`;
+    const firstNameOnly = firstname.toLowerCase().trim();
+    const lastNameOnly = lastname.toLowerCase().trim();
+
+    // Prüfe alle Varianten
+    const variants = [fullName, firstNameOnly, lastNameOnly];
+    const allSimilarTerms = [];
+
+    for (const variant of variants) {
+        // 1. Direkte Levenshtein-Prüfung
+        const similarTerms = findSimilarTerms(variant, blacklistTerms, threshold);
+        allSimilarTerms.push(...similarTerms);
+
+        // 2. Teilstring-Matching: Prüfe alle Wörter im Variant gegen Blacklist
+        const words = variant.split(/\s+/);
+        for (const word of words) {
+            if (word.length >= 2) { // Nur Wörter mit mindestens 2 Zeichen
+                const wordSimilarTerms = findSimilarTerms(word, blacklistTerms, threshold);
+                allSimilarTerms.push(...wordSimilarTerms);
+            }
+        }
+
+        // 3. Teilstring-Matching: Prüfe Blacklist-Begriffe gegen Variant
+        for (const blacklistTerm of blacklistTerms) {
+            const normalizedTerm = blacklistTerm.toLowerCase().trim();
+            if (normalizedTerm.length >= 2) {
+                // Prüfe ob Blacklist-Begriff als Teilstring im Variant vorkommt
+                if (variant.includes(normalizedTerm)) {
+                    allSimilarTerms.push({
+                        term: blacklistTerm,
+                        distance: 0, // Exakte Teilstring-Übereinstimmung
+                        levenshteinDistance: 0,
+                        matchType: 'substring'
+                    });
+                } else {
+                    // Prüfe Levenshtein für Teilstrings
+                    const words = variant.split(/\s+/);
+                    for (const word of words) {
+                        if (word.length >= 2) {
+                            const distance = normalizedLevenshteinDistance(word, normalizedTerm);
+                            if (distance <= threshold) {
+                                allSimilarTerms.push({
+                                    term: blacklistTerm,
+                                    distance: distance,
+                                    levenshteinDistance: levenshteinDistance(word, normalizedTerm),
+                                    matchType: 'substring-similar'
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Entferne Duplikate und sortiere nach Distanz
+    const uniqueSimilarTerms = allSimilarTerms.reduce((acc, current) => {
+        const existing = acc.find(item => item.term === current.term);
+        if (!existing || current.distance < existing.distance) {
+            return acc.filter(item => item.term !== current.term).concat(current);
+        }
+        return acc;
+    }, []);
+
+    return {
+        hasSimilarTerms: uniqueSimilarTerms.length > 0,
+        similarTerms: uniqueSimilarTerms.sort((a, b) => a.distance - b.distance),
+        bestMatch: uniqueSimilarTerms.length > 0 ? uniqueSimilarTerms[0] : null
+    };
+}
+
+/**
+ * Konfigurierbare Schwellenwerte für verschiedene Kategorien
+ */
+const THRESHOLDS = {
+    historical: 0.2,      // Sehr streng für historische Begriffe
+    offensive: 0.25,      // Streng für beleidigende Begriffe
+    titles: 0.3,          // Normal für Titel
+    brands: 0.35,         // Etwas lockerer für Marken
+    inappropriate: 0.3    // Normal für unpassende Begriffe
+};
+
+/**
+ * Performance-optimierte Version für große Blacklists
+ * Verwendet Trigram-Index für bessere Performance
+ */
+class TrigramIndex {
+    constructor() {
+        this.index = new Map();
+    }
+
+    /**
+     * Erstellt Trigramme aus einem String
+     * @param {string} str - Eingabe-String
+     * @returns {Array} - Array von Trigrammen
+     */
+    createTrigrams(str) {
+        const normalized = str.toLowerCase().trim();
+        const trigrams = [];
+
+        for (let i = 0; i < normalized.length - 2; i++) {
+            trigrams.push(normalized.substring(i, i + 3));
+        }
+
+        return trigrams;
+    }
+
+    /**
+     * Fügt einen Begriff zum Index hinzu
+     * @param {string} term - Begriff
+     * @param {string} category - Kategorie
+     */
+    addTerm(term, category) {
+        const trigrams = this.createTrigrams(term);
+        for (const trigram of trigrams) {
+            if (!this.index.has(trigram)) {
+                this.index.set(trigram, []);
+            }
+            this.index.get(trigram).push({ term, category });
+        }
+    }
+
+    /**
+     * Findet Kandidaten basierend auf Trigram-Übereinstimmung
+     * @param {string} input - Eingabe-String
+     * @param {number} minTrigrams - Mindestanzahl übereinstimmender Trigramme
+     * @returns {Array} - Array von Kandidaten
+     */
+    findCandidates(input, minTrigrams = 1) {
+        const inputTrigrams = this.createTrigrams(input);
+        const candidateCount = new Map();
+
+        for (const trigram of inputTrigrams) {
+            if (this.index.has(trigram)) {
+                for (const candidate of this.index.get(trigram)) {
+                    const key = `${candidate.term}|${candidate.category}`;
+                    candidateCount.set(key, (candidateCount.get(key) || 0) + 1);
+                }
+            }
+        }
+
+        // Filtere Kandidaten mit mindestens minTrigrams Übereinstimmungen
+        const candidates = [];
+        for (const [key, count] of candidateCount) {
+            if (count >= minTrigrams) {
+                const [term, category] = key.split('|');
+                candidates.push({ term, category });
+            }
+        }
+
+        return candidates;
+    }
+}
+
+/**
+ * Performance-optimierte Blacklist-Prüfung mit Trigram-Index
+ * @param {string} firstname - Vorname
+ * @param {string} lastname - Nachname
+ * @param {Object} blacklist - Blacklist gruppiert nach Kategorien
+ * @param {TrigramIndex} trigramIndex - Trigram-Index
+ * @returns {Object} - Prüfungsergebnis
+ */
+function checkWithTrigramIndex(firstname, lastname, blacklist, trigramIndex) {
+    const fullName = `${firstname.toLowerCase().trim()} ${lastname.toLowerCase().trim()}`;
+    const firstNameOnly = firstname.toLowerCase().trim();
+    const lastNameOnly = lastname.toLowerCase().trim();
+
+    const variants = [fullName, firstNameOnly, lastNameOnly];
+    const allSimilarTerms = [];
+
+    for (const variant of variants) {
+        // Finde Kandidaten mit Trigram-Index
+        const candidates = trigramIndex.findCandidates(variant, 1);
+
+        // Prüfe nur Kandidaten mit Levenshtein
+        for (const candidate of candidates) {
+            const categoryTerms = blacklist[candidate.category] || [];
+            const similarTerms = findSimilarTerms(variant, categoryTerms, THRESHOLDS[candidate.category] || 0.3);
+            allSimilarTerms.push(...similarTerms);
+        }
+    }
+
+    // Entferne Duplikate und sortiere
+    const uniqueSimilarTerms = allSimilarTerms.reduce((acc, current) => {
+        const existing = acc.find(item => item.term === current.term);
+        if (!existing || current.distance < existing.distance) {
+            return acc.filter(item => item.term !== current.term).concat(current);
+        }
+        return acc;
+    }, []);
+
+    return {
+        hasSimilarTerms: uniqueSimilarTerms.length > 0,
+        similarTerms: uniqueSimilarTerms.sort((a, b) => a.distance - b.distance),
+        bestMatch: uniqueSimilarTerms.length > 0 ? uniqueSimilarTerms[0] : null
+    };
+}
+
+/**
+ * Kategorie-spezifische Levenshtein-Prüfung
+ * @param {string} firstname - Vorname
+ * @param {string} lastname - Nachname
+ * @param {Array} blacklistTerms - Array von Blacklist-Begriffen
+ * @param {string} category - Kategorie der Begriffe
+ * @returns {Object} - Prüfungsergebnis
+ */
+function checkWithCategoryThreshold(firstname, lastname, blacklistTerms, category) {
+    const threshold = THRESHOLDS[category] || 0.3;
+    return checkWithLevenshtein(firstname, lastname, blacklistTerms, threshold);
+}
+
+module.exports = {
+    levenshteinDistance,
+    normalizedLevenshteinDistance,
+    isSimilarToBlacklistTerm,
+    findSimilarTerms,
+    checkWithLevenshtein,
+    checkWithCategoryThreshold,
+    checkWithTrigramIndex,
+    TrigramIndex,
+    THRESHOLDS
+};
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..ba94442
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,20 @@
+version: '3.8'
+
+services:
+  
+  app:
+    build: .
+    environment:
+      DB_HOST: host.docker.internal
+      DB_PORT: 5432
+      DB_NAME: ninjacross
+      DB_USER: reptil1990
+      DB_PASSWORD: \!Delfine1\!\!\!
+      DB_SSL: "false"
+      PORT: 3000
+      LICENSE_SECRET: 542ff224606c61fb3024e22f76ef9ac8
+    ports:
+      - "3000:3000"
+    volumes:
+      - .:/app
+    restart: unless-stopped
\ No newline at end of file
diff --git a/dockerfile b/dockerfile
new file mode 100644
index 0000000..e40bee0
--- /dev/null
+++ b/dockerfile
@@ -0,0 +1,18 @@
+# Use official Node.js LTS image
+FROM node:18
+
+# Set working directory
+WORKDIR /app
+
+# Copy package files and install dependencies
+COPY package.json package-lock.json* ./
+RUN npm install --production
+
+# Copy the rest of the app
+COPY . .
+
+# Expose the port (default 3000)
+EXPOSE 3000
+
+# Start the server
+CMD ["npm", "start"]
\ No newline at end of file
diff --git a/lib/achievementSystem.js b/lib/achievementSystem.js
new file mode 100644
index 0000000..519be2c
--- /dev/null
+++ b/lib/achievementSystem.js
@@ -0,0 +1,880 @@
+/**
+ * NinjaCross Achievement System
+ * 
+ * JavaScript-basierte Achievement-Logik für das NinjaCross Parkour System.
+ * Liest Achievement-Definitionen aus der Datenbank und prüft/vergibt Achievements.
+ * 
+ * @author NinjaCross Team
+ * @version 1.0.0
+ */
+
+const { Pool } = require('pg');
+require('dotenv').config();
+
+// Database connection
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    database: process.env.DB_NAME,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    ssl: process.env.DB_SSL === 'true' ? { rejectUnauthorized: false } : false
+});
+
+class AchievementSystem {
+    constructor() {
+        this.achievements = new Map();
+        this.playerAchievements = new Map();
+    }
+
+    /**
+     * Lädt alle aktiven Achievements aus der Datenbank
+     */
+    async loadAchievements() {
+        try {
+            const result = await pool.query(`
+                SELECT id, name, description, category, condition_type, condition_value, icon, points, can_be_earned_multiple_times
+                FROM achievements 
+                WHERE is_active = true
+                ORDER BY category, condition_type
+            `);
+            
+            this.achievements.clear();
+            result.rows.forEach(achievement => {
+                this.achievements.set(achievement.id, achievement);
+            });
+            
+            console.log(`📋 ${this.achievements.size} Achievements geladen`);
+            return true;
+        } catch (error) {
+            console.error('❌ Fehler beim Laden der Achievements:', error);
+            return false;
+        }
+    }
+
+    /**
+     * Lädt alle Spieler-Achievements für einen Spieler
+     * Jetzt werden alle Completions geladen (nicht nur die neueste)
+     */
+    async loadPlayerAchievements(playerId) {
+        try {
+            // Initialisiere immer eine leere Map für den Spieler
+            this.playerAchievements.set(playerId, new Map());
+            
+            const result = await pool.query(`
+                SELECT pa.achievement_id, pa.progress, pa.is_completed, pa.earned_at
+                FROM player_achievements pa
+                WHERE pa.player_id = $1
+                ORDER BY pa.earned_at DESC
+            `, [playerId]);
+            
+            // Gruppiere nach achievement_id und zähle Completions
+            const achievementCounts = new Map();
+            
+            result.rows.forEach(pa => {
+                if (!achievementCounts.has(pa.achievement_id)) {
+                    achievementCounts.set(pa.achievement_id, {
+                        count: 0,
+                        latest: pa
+                    });
+                }
+                achievementCounts.get(pa.achievement_id).count++;
+            });
+            
+            // Speichere die neueste Completion und die Anzahl
+            achievementCounts.forEach((data, achievementId) => {
+                this.playerAchievements.get(playerId).set(achievementId, {
+                    ...data.latest,
+                    completion_count: data.count
+                });
+            });
+            
+            // Count unique achievements and duplicates
+            const uniqueAchievements = new Set(result.rows.map(row => row.achievement_id));
+            const totalCount = result.rows.length;
+            const uniqueCount = uniqueAchievements.size;
+            const duplicateCount = totalCount - uniqueCount;
+            
+            if (duplicateCount > 0) {
+                console.log(`📋 ${totalCount} Achievements für Spieler ${playerId} geladen (${uniqueCount} eindeutige, ${duplicateCount} doppelt)`);
+            } else {
+                console.log(`📋 ${totalCount} Achievements für Spieler ${playerId} geladen`);
+            }
+            return true;
+        } catch (error) {
+            console.error(`❌ Fehler beim Laden der Spieler-Achievements für ${playerId}:`, error);
+            return false;
+        }
+    }
+
+    /**
+     * Prüft alle Achievements für einen Spieler
+     */
+    async checkAllAchievements(playerId) {
+        console.log(`🎯 Prüfe Achievements für Spieler ${playerId}...`);
+        
+        // Lade Spieler-Achievements
+        await this.loadPlayerAchievements(playerId);
+        
+        const newAchievements = [];
+        
+        // Prüfe alle Achievement-Kategorien
+        await this.checkConsistencyAchievements(playerId, newAchievements);
+        await this.checkImprovementAchievements(playerId, newAchievements);
+        await this.checkSeasonalAchievements(playerId, newAchievements);
+        await this.checkBestTimeAchievements(playerId, newAchievements);
+        
+        console.log(`✅ ${newAchievements.length} neue Achievements für Spieler ${playerId}`);
+        return newAchievements;
+    }
+
+    /**
+     * Prüft sofortige Achievements für einen Spieler (bei neuer Zeit)
+     * Diese Achievements werden sofort vergeben, nicht nur um 19:00 Uhr
+     */
+    async checkImmediateAchievements(playerId) {
+        console.log(`⚡ Prüfe sofortige Achievements für Spieler ${playerId}...`);
+        
+        // Lade alle Achievements (falls noch nicht geladen)
+        if (this.achievements.size === 0) {
+            console.log('📋 Lade alle Achievements...');
+            await this.loadAchievements();
+        }
+        
+        // Lade Spieler-Achievements
+        await this.loadPlayerAchievements(playerId);
+        
+        const newAchievements = [];
+        
+        // Prüfe nur sofortige Achievement-Kategorien
+        await this.checkImmediateConsistencyAchievements(playerId, newAchievements);
+        await this.checkImprovementAchievements(playerId, newAchievements);
+        await this.checkSeasonalAchievements(playerId, newAchievements);
+        // Best-Time Achievements werden NICHT sofort geprüft (nur um 19:00 Uhr)
+        
+        if (newAchievements.length > 0) {
+            console.log(`🏆 ${newAchievements.length} sofortige Achievements für Spieler ${playerId}:`);
+            newAchievements.forEach(achievement => {
+                console.log(`   ${achievement.icon} ${achievement.name} (+${achievement.points} Punkte)`);
+            });
+        }
+        
+        return newAchievements;
+    }
+
+    /**
+     * Prüft Konsistenz-basierte Achievements
+     */
+    async checkConsistencyAchievements(playerId, newAchievements) {
+        // Erste Schritte
+        await this.checkFirstTimeAchievement(playerId, newAchievements);
+        
+        // Versuche pro Tag
+        await this.checkAttemptsPerDayAchievements(playerId, newAchievements);
+        
+        // Einzigartige Tage
+        await this.checkUniqueDaysAchievements(playerId, newAchievements);
+    }
+
+    /**
+     * Prüft nur sofortige Konsistenz-basierte Achievements
+     */
+    async checkImmediateConsistencyAchievements(playerId, newAchievements) {
+        // Erste Schritte
+        await this.checkFirstTimeAchievement(playerId, newAchievements);
+        
+        // Versuche pro Tag
+        await this.checkAttemptsPerDayAchievements(playerId, newAchievements);
+        
+        // Einzigartige Tage werden NICHT sofort geprüft (nur um 19:00 Uhr)
+    }
+
+    /**
+     * Prüft "Erste Schritte" Achievement
+     */
+    async checkFirstTimeAchievement(playerId, newAchievements) {
+        const achievement = Array.from(this.achievements.values())
+            .find(a => a.category === 'consistency' && a.condition_type === 'first_time');
+        
+        if (!achievement) return;
+
+        // Prüfe ob bereits erreicht
+        if (this.isAchievementCompleted(playerId, achievement.id)) return;
+
+        // Zähle Gesamtversuche
+        const result = await pool.query(`
+            SELECT COUNT(*) as count
+            FROM times t
+            WHERE t.player_id = $1
+        `, [playerId]);
+
+        const totalAttempts = parseInt(result.rows[0].count);
+        
+        if (totalAttempts >= achievement.condition_value) {
+            await this.awardAchievement(playerId, achievement, totalAttempts, newAchievements);
+        }
+    }
+
+    /**
+     * Prüft "Versuche pro Tag" Achievements
+     */
+    async checkAttemptsPerDayAchievements(playerId, newAchievements) {
+        const achievements = Array.from(this.achievements.values())
+            .filter(a => a.category === 'consistency' && a.condition_type === 'attempts_per_day');
+
+        // Zähle Versuche heute
+        const result = await pool.query(`
+            SELECT COUNT(*) as count
+            FROM times t
+            WHERE t.player_id = $1 
+            AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+        `, [playerId]);
+
+        const attemptsToday = parseInt(result.rows[0].count);
+
+        for (const achievement of achievements) {
+            if (this.isAchievementCompleted(playerId, achievement.id)) continue;
+            
+            // Prüfe ob das Achievement heute bereits vergeben wurde
+            const alreadyEarnedToday = await pool.query(`
+                SELECT COUNT(*) as count
+                FROM player_achievements pa
+                WHERE pa.player_id = $1 
+                AND pa.achievement_id = $2
+                AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+            `, [playerId, achievement.id]);
+            
+            if (parseInt(alreadyEarnedToday.rows[0].count) > 0) continue;
+            
+            if (attemptsToday >= achievement.condition_value) {
+                await this.awardAchievement(playerId, achievement, attemptsToday, newAchievements);
+            }
+        }
+    }
+
+    /**
+     * Prüft "Einzigartige Tage" Achievements
+     */
+    async checkUniqueDaysAchievements(playerId, newAchievements) {
+        const achievements = Array.from(this.achievements.values())
+            .filter(a => a.category === 'consistency' && a.condition_type === 'unique_days');
+
+        // Zähle einzigartige Tage
+        const result = await pool.query(`
+            SELECT COUNT(DISTINCT DATE(t.created_at AT TIME ZONE 'Europe/Berlin')) as count
+            FROM times t
+            WHERE t.player_id = $1
+        `, [playerId]);
+
+        const uniqueDays = parseInt(result.rows[0].count);
+
+        for (const achievement of achievements) {
+            if (this.isAchievementCompleted(playerId, achievement.id)) continue;
+            
+            if (uniqueDays >= achievement.condition_value) {
+                await this.awardAchievement(playerId, achievement, uniqueDays, newAchievements);
+            }
+        }
+    }
+
+    /**
+     * Prüft Verbesserungs-basierte Achievements
+     */
+    async checkImprovementAchievements(playerId, newAchievements) {
+        const achievements = Array.from(this.achievements.values())
+            .filter(a => a.category === 'improvement' && a.condition_type === 'time_improvement');
+
+        // Hole beste und zweitbeste Zeit
+        const result = await pool.query(`
+            SELECT 
+                MIN(recorded_time) as best_time,
+                (SELECT MIN(recorded_time) 
+                 FROM times t2 
+                 WHERE t2.player_id = $1 
+                 AND t2.recorded_time > (SELECT MIN(recorded_time) FROM times t3 WHERE t3.player_id = $1)
+                ) as second_best_time
+            FROM times t
+            WHERE t.player_id = $1
+        `, [playerId]);
+
+        const { best_time, second_best_time } = result.rows[0];
+        
+        if (!best_time || !second_best_time) return;
+
+        // Berechne Verbesserung in Sekunden
+        const improvementSeconds = Math.floor((new Date(second_best_time) - new Date(best_time)) / 1000);
+
+        for (const achievement of achievements) {
+            if (this.isAchievementCompleted(playerId, achievement.id)) continue;
+            
+            if (improvementSeconds >= achievement.condition_value) {
+                await this.awardAchievement(playerId, achievement, improvementSeconds, newAchievements);
+            }
+        }
+    }
+
+    /**
+     * Prüft Saisonale Achievements
+     */
+    async checkSeasonalAchievements(playerId, newAchievements) {
+        const now = new Date();
+        const currentHour = now.getHours();
+        const currentMonth = now.getMonth() + 1; // JavaScript months are 0-based
+        const currentDayOfWeek = now.getDay(); // 0 = Sunday
+
+        // Zeit-basierte Achievements
+        await this.checkTimeBasedAchievements(playerId, currentHour, currentDayOfWeek, newAchievements);
+        
+        // Monatliche Achievements
+        await this.checkMonthlyAchievements(playerId, currentMonth, newAchievements);
+        
+        // Jahreszeiten-Achievements
+        await this.checkSeasonalTimeAchievements(playerId, currentMonth, newAchievements);
+    }
+
+    /**
+     * Prüft zeit-basierte Achievements (Wochenende, Morgen, etc.)
+     */
+    async checkTimeBasedAchievements(playerId, currentHour, currentDayOfWeek, newAchievements) {
+        const timeAchievements = [
+            { condition: 'weekend_play', check: () => currentDayOfWeek === 0 || currentDayOfWeek === 6 },
+            { condition: 'morning_play', check: () => currentHour < 10 },
+            { condition: 'afternoon_play', check: () => currentHour >= 14 && currentHour < 18 },
+            { condition: 'evening_play', check: () => currentHour >= 18 }
+        ];
+
+        for (const timeAchievement of timeAchievements) {
+            if (!timeAchievement.check()) continue;
+
+            const achievements = Array.from(this.achievements.values())
+                .filter(a => a.category === 'seasonal' && a.condition_type === timeAchievement.condition);
+
+            for (const achievement of achievements) {
+                if (this.isAchievementCompleted(playerId, achievement.id)) continue;
+
+                // Prüfe ob das Achievement heute bereits vergeben wurde
+                const alreadyEarnedToday = await pool.query(`
+                    SELECT COUNT(*) as count
+                    FROM player_achievements pa
+                    WHERE pa.player_id = $1 
+                    AND pa.achievement_id = $2
+                    AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+                `, [playerId, achievement.id]);
+                
+                if (parseInt(alreadyEarnedToday.rows[0].count) > 0) continue;
+
+                // Prüfe ob Spieler zu dieser Zeit gespielt hat
+                const hasPlayed = await this.checkTimeBasedPlay(playerId, timeAchievement.condition);
+                
+                if (hasPlayed) {
+                    await this.awardAchievement(playerId, achievement, 1, newAchievements);
+                }
+            }
+        }
+    }
+
+    /**
+     * Prüft ob Spieler zu einer bestimmten Zeit gespielt hat
+     */
+    async checkTimeBasedPlay(playerId, conditionType) {
+        let query = '';
+        
+        switch (conditionType) {
+            case 'weekend_play':
+                query = `
+                    SELECT EXISTS(
+                        SELECT 1 FROM times t 
+                        WHERE t.player_id = $1 
+                        AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+                        AND EXTRACT(DOW FROM t.created_at AT TIME ZONE 'Europe/Berlin') IN (0, 6)
+                    ) as has_played
+                `;
+                break;
+            case 'morning_play':
+                query = `
+                    SELECT EXISTS(
+                        SELECT 1 FROM times t 
+                        WHERE t.player_id = $1 
+                        AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+                        AND EXTRACT(HOUR FROM t.created_at AT TIME ZONE 'Europe/Berlin') < 10
+                    ) as has_played
+                `;
+                break;
+            case 'afternoon_play':
+                query = `
+                    SELECT EXISTS(
+                        SELECT 1 FROM times t 
+                        WHERE t.player_id = $1 
+                        AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+                        AND EXTRACT(HOUR FROM t.created_at AT TIME ZONE 'Europe/Berlin') BETWEEN 14 AND 17
+                    ) as has_played
+                `;
+                break;
+            case 'evening_play':
+                query = `
+                    SELECT EXISTS(
+                        SELECT 1 FROM times t 
+                        WHERE t.player_id = $1 
+                        AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+                        AND EXTRACT(HOUR FROM t.created_at AT TIME ZONE 'Europe/Berlin') >= 18
+                    ) as has_played
+                `;
+                break;
+        }
+
+        if (!query) return false;
+
+        const result = await pool.query(query, [playerId]);
+        return result.rows[0].has_played;
+    }
+
+    /**
+     * Prüft monatliche Achievements (einmal pro Jahr)
+     */
+    async checkMonthlyAchievements(playerId, currentMonth, newAchievements) {
+        const monthNames = [
+            'january', 'february', 'march', 'april', 'may', 'june',
+            'july', 'august', 'september', 'october', 'november', 'december'
+        ];
+
+        const currentMonthName = monthNames[currentMonth - 1];
+        const currentYear = new Date().getFullYear();
+        
+        const achievements = Array.from(this.achievements.values())
+            .filter(a => a.category === 'monthly' && a.condition_type === currentMonthName);
+
+        for (const achievement of achievements) {
+            if (this.isAchievementCompleted(playerId, achievement.id)) continue;
+
+            // Prüfe ob Spieler in diesem Monat dieses Jahres gespielt hat
+            const result = await pool.query(`
+                SELECT EXISTS(
+                    SELECT 1 FROM times t 
+                    WHERE t.player_id = $1 
+                    AND EXTRACT(MONTH FROM t.created_at AT TIME ZONE 'Europe/Berlin') = $2
+                    AND EXTRACT(YEAR FROM t.created_at AT TIME ZONE 'Europe/Berlin') = $3
+                ) as has_played
+            `, [playerId, currentMonth, currentYear]);
+
+            if (result.rows[0].has_played) {
+                // Prüfe ob Achievement bereits in diesem Jahr erreicht wurde
+                const alreadyEarnedThisYear = await pool.query(`
+                    SELECT COUNT(*) as count
+                    FROM player_achievements pa
+                    WHERE pa.player_id = $1 
+                    AND pa.achievement_id = $2
+                    AND EXTRACT(YEAR FROM pa.earned_at AT TIME ZONE 'Europe/Berlin') = $3
+                `, [playerId, achievement.id, currentYear]);
+
+                if (parseInt(alreadyEarnedThisYear.rows[0].count) === 0) {
+                    await this.awardAchievement(playerId, achievement, 1, newAchievements);
+                }
+            }
+        }
+    }
+
+    /**
+     * Prüft Jahreszeiten-Achievements (einmal pro Jahr)
+     */
+    async checkSeasonalTimeAchievements(playerId, currentMonth, newAchievements) {
+        const season = this.getSeason(currentMonth);
+        const currentYear = new Date().getFullYear();
+        
+        const achievements = Array.from(this.achievements.values())
+            .filter(a => a.category === 'seasonal' && a.condition_type === season);
+
+        for (const achievement of achievements) {
+            if (this.isAchievementCompleted(playerId, achievement.id)) continue;
+
+            // Prüfe ob Spieler in dieser Jahreszeit dieses Jahres gespielt hat
+            const monthRanges = {
+                spring: [3, 4, 5],
+                summer: [6, 7, 8],
+                autumn: [9, 10, 11],
+                winter: [12, 1, 2]
+            };
+
+            const months = monthRanges[season];
+            const result = await pool.query(`
+                SELECT EXISTS(
+                    SELECT 1 FROM times t 
+                    WHERE t.player_id = $1 
+                    AND EXTRACT(MONTH FROM t.created_at AT TIME ZONE 'Europe/Berlin') = ANY($2)
+                    AND EXTRACT(YEAR FROM t.created_at AT TIME ZONE 'Europe/Berlin') = $3
+                ) as has_played
+            `, [playerId, months, currentYear]);
+
+            if (result.rows[0].has_played) {
+                // Prüfe ob Achievement bereits in diesem Jahr erreicht wurde
+                const alreadyEarnedThisYear = await pool.query(`
+                    SELECT COUNT(*) as count
+                    FROM player_achievements pa
+                    WHERE pa.player_id = $1 
+                    AND pa.achievement_id = $2
+                    AND EXTRACT(YEAR FROM pa.earned_at AT TIME ZONE 'Europe/Berlin') = $3
+                `, [playerId, achievement.id, currentYear]);
+
+                if (parseInt(alreadyEarnedThisYear.rows[0].count) === 0) {
+                    await this.awardAchievement(playerId, achievement, 1, newAchievements);
+                }
+            }
+        }
+    }
+
+    /**
+     * Prüft Best-Time Achievements (nur um 19:00 Uhr)
+     */
+    async checkBestTimeAchievements(playerId, newAchievements) {
+        const now = new Date();
+        const currentHour = now.getHours();
+        const currentDayOfWeek = now.getDay();
+        const currentDate = now.toISOString().split('T')[0];
+        const isLastDayOfMonth = this.isLastDayOfMonth(now);
+
+        // Nur um 19:00 Uhr prüfen
+        if (currentHour !== 19) return;
+
+        // Tageskönig (jeden Tag um 19:00)
+        await this.checkDailyBest(playerId, currentDate, newAchievements);
+
+        // Wochenchampion (nur Sonntag um 19:00)
+        if (currentDayOfWeek === 0) {
+            await this.checkWeeklyBest(playerId, currentDate, newAchievements);
+        }
+
+        // Monatsmeister (nur am letzten Tag des Monats um 19:00)
+        if (isLastDayOfMonth) {
+            await this.checkMonthlyBest(playerId, currentDate, newAchievements);
+        }
+    }
+
+    /**
+     * Prüft Tageskönig Achievement pro Standort
+     */
+    async checkDailyBest(playerId, currentDate, newAchievements) {
+        const achievement = Array.from(this.achievements.values())
+            .find(a => a.category === 'time' && a.condition_type === 'best_time_daily_location');
+
+        if (!achievement) return;
+
+        // Hole alle Standorte, an denen der Spieler heute gespielt hat
+        const locationsResult = await pool.query(`
+            SELECT DISTINCT t.location_id, l.name as location_name
+            FROM times t
+            INNER JOIN locations l ON t.location_id = l.id
+            WHERE t.player_id = $1 
+            AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = $2
+        `, [playerId, currentDate]);
+
+        for (const location of locationsResult.rows) {
+            // Prüfe ob das Achievement heute bereits für diesen Standort vergeben wurde
+            const alreadyEarnedToday = await pool.query(`
+                SELECT COUNT(*) as count
+                FROM player_achievements pa
+                WHERE pa.player_id = $1 
+                AND pa.achievement_id = $2
+                AND pa.location_id = $3
+                AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+            `, [playerId, achievement.id, location.location_id]);
+            
+            if (parseInt(alreadyEarnedToday.rows[0].count) > 0) continue;
+
+            // Hole beste Zeit des Spielers heute an diesem Standort
+            const playerResult = await pool.query(`
+                SELECT MIN(recorded_time) as best_time
+                FROM times t
+                WHERE t.player_id = $1 
+                AND t.location_id = $2
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = $3
+            `, [playerId, location.location_id, currentDate]);
+
+            // Hole beste Zeit des Tages an diesem Standort
+            const dailyResult = await pool.query(`
+                SELECT MIN(recorded_time) as best_time
+                FROM times t
+                WHERE t.location_id = $1
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = $2
+            `, [location.location_id, currentDate]);
+
+            const playerBest = playerResult.rows[0].best_time;
+            const dailyBest = dailyResult.rows[0].best_time;
+
+            if (playerBest && dailyBest && playerBest === dailyBest) {
+                await this.awardAchievement(playerId, achievement, 1, newAchievements, location.location_id);
+                console.log(`🏆 Tageskönig Achievement vergeben für Standort: ${location.location_name}`);
+            }
+        }
+    }
+
+    /**
+     * Prüft Wochenchampion Achievement pro Standort
+     */
+    async checkWeeklyBest(playerId, currentDate, newAchievements) {
+        const achievement = Array.from(this.achievements.values())
+            .find(a => a.category === 'time' && a.condition_type === 'best_time_weekly_location');
+
+        if (!achievement) return;
+
+        // Berechne Woche
+        const currentDateObj = new Date(currentDate);
+        const dayOfWeek = currentDateObj.getDay();
+        const weekStart = new Date(currentDateObj);
+        weekStart.setDate(currentDateObj.getDate() - (dayOfWeek === 0 ? 6 : dayOfWeek - 1));
+        const weekStartStr = weekStart.toISOString().split('T')[0];
+
+        // Hole alle Standorte, an denen der Spieler diese Woche gespielt hat
+        const locationsResult = await pool.query(`
+            SELECT DISTINCT t.location_id, l.name as location_name
+            FROM times t
+            INNER JOIN locations l ON t.location_id = l.id
+            WHERE t.player_id = $1 
+            AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') >= $2
+            AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') <= $3
+        `, [playerId, weekStartStr, currentDate]);
+
+        for (const location of locationsResult.rows) {
+            // Prüfe ob das Achievement diese Woche bereits für diesen Standort vergeben wurde
+            const alreadyEarnedThisWeek = await pool.query(`
+                SELECT COUNT(*) as count
+                FROM player_achievements pa
+                WHERE pa.player_id = $1 
+                AND pa.achievement_id = $2
+                AND pa.location_id = $3
+                AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') >= $4
+                AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') <= $5
+            `, [playerId, achievement.id, location.location_id, weekStartStr, currentDate]);
+            
+            if (parseInt(alreadyEarnedThisWeek.rows[0].count) > 0) continue;
+
+            // Hole beste Zeit des Spielers diese Woche an diesem Standort
+            const playerResult = await pool.query(`
+                SELECT MIN(recorded_time) as best_time
+                FROM times t
+                WHERE t.player_id = $1 
+                AND t.location_id = $2
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') >= $3
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') <= $4
+            `, [playerId, location.location_id, weekStartStr, currentDate]);
+
+            // Hole beste Zeit der Woche an diesem Standort
+            const weeklyResult = await pool.query(`
+                SELECT MIN(recorded_time) as best_time
+                FROM times t
+                WHERE t.location_id = $1
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') >= $2
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') <= $3
+            `, [location.location_id, weekStartStr, currentDate]);
+
+            const playerBest = playerResult.rows[0].best_time;
+            const weeklyBest = weeklyResult.rows[0].best_time;
+
+            if (playerBest && weeklyBest && playerBest === weeklyBest) {
+                await this.awardAchievement(playerId, achievement, 1, newAchievements, location.location_id);
+                console.log(`🏆 Wochenchampion Achievement vergeben für Standort: ${location.location_name}`);
+            }
+        }
+    }
+
+    /**
+     * Prüft Monatsmeister Achievement pro Standort
+     */
+    async checkMonthlyBest(playerId, currentDate, newAchievements) {
+        const achievement = Array.from(this.achievements.values())
+            .find(a => a.category === 'time' && a.condition_type === 'best_time_monthly_location');
+
+        if (!achievement) return;
+
+        // Berechne Monatsstart
+        const currentDateObj = new Date(currentDate);
+        const monthStart = new Date(currentDateObj.getFullYear(), currentDateObj.getMonth(), 1);
+        const monthStartStr = monthStart.toISOString().split('T')[0];
+
+        // Hole alle Standorte, an denen der Spieler diesen Monat gespielt hat
+        const locationsResult = await pool.query(`
+            SELECT DISTINCT t.location_id, l.name as location_name
+            FROM times t
+            INNER JOIN locations l ON t.location_id = l.id
+            WHERE t.player_id = $1 
+            AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') >= $2
+            AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') <= $3
+        `, [playerId, monthStartStr, currentDate]);
+
+        for (const location of locationsResult.rows) {
+            // Prüfe ob das Achievement diesen Monat bereits für diesen Standort vergeben wurde
+            const alreadyEarnedThisMonth = await pool.query(`
+                SELECT COUNT(*) as count
+                FROM player_achievements pa
+                WHERE pa.player_id = $1 
+                AND pa.achievement_id = $2
+                AND pa.location_id = $3
+                AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') >= $4
+                AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') <= $5
+            `, [playerId, achievement.id, location.location_id, monthStartStr, currentDate]);
+            
+            if (parseInt(alreadyEarnedThisMonth.rows[0].count) > 0) continue;
+
+            // Hole beste Zeit des Spielers diesen Monat an diesem Standort
+            const playerResult = await pool.query(`
+                SELECT MIN(recorded_time) as best_time
+                FROM times t
+                WHERE t.player_id = $1 
+                AND t.location_id = $2
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') >= $3
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') <= $4
+            `, [playerId, location.location_id, monthStartStr, currentDate]);
+
+            // Hole beste Zeit des Monats an diesem Standort
+            const monthlyResult = await pool.query(`
+                SELECT MIN(recorded_time) as best_time
+                FROM times t
+                WHERE t.location_id = $1
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') >= $2
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') <= $3
+            `, [location.location_id, monthStartStr, currentDate]);
+
+            const playerBest = playerResult.rows[0].best_time;
+            const monthlyBest = monthlyResult.rows[0].best_time;
+
+            if (playerBest && monthlyBest && playerBest === monthlyBest) {
+                await this.awardAchievement(playerId, achievement, 1, newAchievements, location.location_id);
+                console.log(`🏆 Monatsmeister Achievement vergeben für Standort: ${location.location_name}`);
+            }
+        }
+    }
+
+    /**
+     * Vergibt ein Achievement an einen Spieler
+     * Erstellt immer einen neuen Eintrag (keine Updates mehr)
+     */
+    async awardAchievement(playerId, achievement, progress, newAchievements, locationId = null) {
+        try {
+            await pool.query(`
+                INSERT INTO player_achievements (player_id, achievement_id, progress, is_completed, earned_at, location_id)
+                VALUES ($1, $2, $3, true, NOW(), $4)
+            `, [playerId, achievement.id, progress, locationId]);
+
+            newAchievements.push({
+                id: achievement.id,
+                name: achievement.name,
+                description: achievement.description,
+                icon: achievement.icon,
+                points: achievement.points,
+                progress: progress,
+                locationId: locationId
+            });
+
+            const locationText = locationId ? ` (Standort: ${locationId})` : '';
+            console.log(`🏆 Achievement vergeben: ${achievement.icon} ${achievement.name} (+${achievement.points} Punkte)${locationText}`);
+        } catch (error) {
+            console.error(`❌ Fehler beim Vergeben des Achievements ${achievement.name}:`, error);
+        }
+    }
+
+    /**
+     * Prüft ob ein Achievement bereits erreicht wurde
+     * Berücksichtigt ob das Achievement mehrmals erreicht werden kann
+     */
+    isAchievementCompleted(playerId, achievementId) {
+        const achievement = this.achievements.get(achievementId);
+        if (!achievement) return false;
+        
+        // Wenn das Achievement mehrmals erreicht werden kann, ist es nie "abgeschlossen"
+        if (achievement.can_be_earned_multiple_times) {
+            return false;
+        }
+        
+        // Für einmalige Achievements prüfen wir, ob sie bereits erreicht wurden
+        const playerAchievements = this.playerAchievements.get(playerId);
+        if (!playerAchievements) {
+            console.log(`⚠️ Player achievements not loaded for ${playerId}, assuming not completed`);
+            return false;
+        }
+        
+        return playerAchievements.has(achievementId);
+    }
+
+    /**
+     * Hilfsfunktionen
+     */
+    getSeason(month) {
+        if (month >= 3 && month <= 5) return 'spring';
+        if (month >= 6 && month <= 8) return 'summer';
+        if (month >= 9 && month <= 11) return 'autumn';
+        return 'winter';
+    }
+
+    isLastDayOfMonth(date) {
+        const tomorrow = new Date(date);
+        tomorrow.setDate(date.getDate() + 1);
+        return tomorrow.getMonth() !== date.getMonth();
+    }
+
+    /**
+     * Berechnet die Gesamtpunkte eines Spielers (inklusive aller Completions)
+     */
+    async getPlayerTotalPoints(playerId) {
+        try {
+            const result = await pool.query(`
+                SELECT 
+                    SUM(a.points) as total_points,
+                    COUNT(pa.id) as total_completions
+                FROM player_achievements pa
+                INNER JOIN achievements a ON pa.achievement_id = a.id
+                WHERE pa.player_id = $1 AND pa.is_completed = true
+            `, [playerId]);
+            
+            return {
+                totalPoints: parseInt(result.rows[0].total_points) || 0,
+                totalCompletions: parseInt(result.rows[0].total_completions) || 0
+            };
+        } catch (error) {
+            console.error(`❌ Fehler beim Berechnen der Gesamtpunkte für ${playerId}:`, error);
+            return { totalPoints: 0, totalCompletions: 0 };
+        }
+    }
+
+    /**
+     * Führt tägliche Achievement-Prüfung für alle Spieler durch
+     */
+    async runDailyAchievementCheck() {
+        console.log('🎯 Starte tägliche Achievement-Prüfung...');
+        
+        // Lade Achievements
+        await this.loadAchievements();
+        
+        // Hole alle Spieler, die heute gespielt haben
+        const playersResult = await pool.query(`
+            SELECT DISTINCT p.id, p.firstname, p.lastname
+            FROM players p
+            INNER JOIN times t ON p.id = t.player_id
+            WHERE DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+        `);
+
+        let totalNewAchievements = 0;
+        const allNewAchievements = [];
+
+        for (const player of playersResult.rows) {
+            console.log(`🔍 Prüfe Achievements für ${player.firstname} ${player.lastname}...`);
+            
+            const newAchievements = await this.checkAllAchievements(player.id);
+            totalNewAchievements += newAchievements.length;
+            
+            if (newAchievements.length > 0) {
+                allNewAchievements.push({
+                    player: `${player.firstname} ${player.lastname}`,
+                    achievements: newAchievements
+                });
+            }
+        }
+
+        console.log(`🎉 Tägliche Achievement-Prüfung abgeschlossen!`);
+        console.log(`📊 ${totalNewAchievements} neue Achievements vergeben`);
+        
+        return {
+            totalNewAchievements,
+            playerAchievements: allNewAchievements
+        };
+    }
+}
+
+module.exports = AchievementSystem;
diff --git a/lib/push-service.js b/lib/push-service.js
new file mode 100644
index 0000000..daa7171
--- /dev/null
+++ b/lib/push-service.js
@@ -0,0 +1,162 @@
+const webpush = require('web-push');
+
+// VAPID Keys (sollten in Umgebungsvariablen gespeichert werden)
+const vapidKeys = {
+    publicKey: 'BJmNVx0C3XeVxeKGTP9c-Z4HcuZNmdk6QdiLocZgCmb-miCS0ESFO3W2TvJlRhhNAShV63pWA5p36BTVSetyTds',
+    privateKey: 'HBdRCtmZUAzsWpVjZ2LDaoWliIPHldAb5ExAt8bvDeg'
+};
+
+// Configure web-push
+webpush.setVapidDetails(
+    'mailto:admin@reptilfpv.de',
+    vapidKeys.publicKey,
+    vapidKeys.privateKey
+);
+
+class PushService {
+    constructor() {
+        this.subscriptions = new Map(); // Map<playerId, Set<subscription>>
+    }
+
+    // Subscribe user to push notifications
+    subscribe(userId, subscription) {
+        if (!this.subscriptions.has(userId)) {
+            this.subscriptions.set(userId, new Set());
+        }
+        this.subscriptions.get(userId).add(subscription);
+        console.log(`User ${userId} subscribed to push notifications (${this.subscriptions.get(userId).size} total subscriptions)`);
+    }
+
+    // Unsubscribe user from push notifications
+    unsubscribe(userId) {
+        this.subscriptions.delete(userId);
+        console.log(`User ${userId} unsubscribed from push notifications`);
+    }
+
+    // Unsubscribe specific device from push notifications
+    unsubscribeDevice(userId, endpoint) {
+        const subscriptions = this.subscriptions.get(userId);
+        if (!subscriptions) {
+            console.log(`No subscriptions found for user ${userId}`);
+            return false;
+        }
+
+        // Find and remove the specific subscription by endpoint
+        let removed = false;
+        for (const subscription of subscriptions) {
+            if (subscription.endpoint === endpoint) {
+                subscriptions.delete(subscription);
+                removed = true;
+                break;
+            }
+        }
+
+        // If no subscriptions left, remove the user entirely
+        if (subscriptions.size === 0) {
+            this.subscriptions.delete(userId);
+            console.log(`User ${userId} unsubscribed from push notifications (all devices)`);
+        } else {
+            console.log(`Device ${endpoint} unsubscribed from push notifications for user ${userId} (${subscriptions.size} devices remaining)`);
+        }
+
+        return removed;
+    }
+
+    // Send push notification to specific user
+    async sendToUser(userId, payload) {
+        const subscriptions = this.subscriptions.get(userId);
+        if (!subscriptions || subscriptions.size === 0) {
+            console.log(`No subscriptions found for user ${userId}`);
+            return false;
+        }
+
+        let successCount = 0;
+        let totalCount = subscriptions.size;
+
+        for (const subscription of subscriptions) {
+            try {
+                await webpush.sendNotification(subscription, JSON.stringify(payload));
+                successCount++;
+            } catch (error) {
+                console.error(`Error sending push notification to user ${userId}:`, error);
+                
+                // If subscription is invalid, remove it
+                if (error.statusCode === 410) {
+                    subscriptions.delete(subscription);
+                }
+            }
+        }
+
+        console.log(`Push notification sent to ${successCount}/${totalCount} subscriptions for user ${userId}`);
+        return successCount > 0;
+    }
+
+    // Send push notification to all subscribed users
+    async sendToAll(payload) {
+        const results = [];
+        for (const [userId, subscription] of this.subscriptions) {
+            const result = await this.sendToUser(userId, payload);
+            results.push({ userId, success: result });
+        }
+        return results;
+    }
+
+    // Send achievement notification
+    async sendAchievementNotification(userId, achievementName) {
+        const payload = {
+            title: '🏆 Neues Achievement!',
+            body: `Du hast "${achievementName}" erreicht!`,
+            icon: '/pictures/icon-192.png',
+            badge: '/pictures/icon-192.png',
+            data: {
+                type: 'achievement',
+                achievement: achievementName,
+                timestamp: Date.now()
+            },
+            actions: [
+                {
+                    action: 'view',
+                    title: 'Dashboard öffnen'
+                }
+            ]
+        };
+
+        return await this.sendToUser(userId, payload);
+    }
+
+    // Send best time notification
+    async sendBestTimeNotification(userId, timeType, locationName) {
+        const payload = {
+            title: `🏁 ${timeType} Bestzeit!`,
+            body: `Du hast die beste Zeit in ${locationName} erreicht!`,
+            icon: '/pictures/icon-192.png',
+            badge: '/pictures/icon-192.png',
+            data: {
+                type: 'best_time',
+                timeType: timeType,
+                location: locationName,
+                timestamp: Date.now()
+            },
+            actions: [
+                {
+                    action: 'view',
+                    title: 'Dashboard öffnen'
+                }
+            ]
+        };
+
+        return await this.sendToUser(userId, payload);
+    }
+
+    // Get subscription count
+    getSubscriptionCount() {
+        return this.subscriptions.size;
+    }
+
+    // Get all user IDs with subscriptions
+    getSubscribedUsers() {
+        return Array.from(this.subscriptions.keys());
+    }
+}
+
+module.exports = new PushService();
diff --git a/ninjacross-8a77c8ef79a7.json b/ninjacross-8a77c8ef79a7.json
new file mode 100644
index 0000000..9cf0cf1
--- /dev/null
+++ b/ninjacross-8a77c8ef79a7.json
@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "ninjacross",
+  "private_key_id": "8a77c8ef79a7a7784f022f276a9d3f26eac6c044",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDItq0W+LPbz1Gg\nzXZQm3yiuqun9ZjYYO2G2S5jRm4DcWB+dStfg7fZCOjBI5ziN3mpwWMfn9dogbtG\nAak42Fz8j9sMggDxk98JWfU8eqofJVhB6ADWwPNdoajzBuUO4kVjhqIFrAAHH7mn\ntTgddVut5IxG8vlXxjx/tTgt/tXCWy9AO8J0nG581K8gVMD6jySsrRpVO7q25Lfp\nv8TO6Ke6+0E4DcER0+x1gckPgVPuVU2vluBYUV+JXvzafv9S78FRq9UzPiaNEDYz\nZMAOBmXHB5OE1Y53NaGa9PWHOrNU2PGcC+RcbU1+4fbVKapM8QOOR1Xo8uMe0Kx/\ntKzs7917AgMBAAECggEAGplC1PF+fFm8GpA/5qzEVphgWTDN4Zbuw1kSsatKtwAW\nZovGhLDi80sf9UBv8PajE+EB7tXy6PGQTNW5hEQABqRVxhGQaHNNMmMOgcZLtzbu\nvEUvn0YQuk7LIfG+9zr7MRZNcGz7z/XfV59HYXgE/0VzZY+bhYtKxy3P1SCZWVkZ\n3EgsUIEqDwDviTkcaPgRtbyWyIZdy+uSgvIa+CE1ra+Q0RWK9OJGVJkU3AG44r8i\nR28muIfHWydOy3OO5DrFOkbX+pDGKEAHEQ0pevAOcSMiYlJRBiD7eJyh0dqcgwen\nX8IZ36qBJJofxbPqzjw6a0iWB9jj1oLBrM9Dbg790QKBgQD257zYmde81/jZ8DBm\nTf37ME07KbXPOrj9SqUwsz8kmbTr5QiR9QFJZP443ijs45wIMtroygX4PyTbwjQI\nmNrgxrYP5hGUdmeOdKYtccqH1FBXqTe1UYXgBV16awWURaPH73zGhcvnZNO+oEZl\nuvsG1s3MT4CmPfhy3NUS8taECQKBgQDQG1x/TtTFcmzeaM400wx4VxQSx4GbXEvY\nYImPAHNPsn8PW7wNd7/xW1d0GXPZEjXHGz57jyoCqRdRy+jqh6/3iGS9oCgZNM6z\nF1A6Wxr14IMTQX6uioYtXGev+drp5SPv1G0cqo1y+s2RQk788FAbF2tZqJHf/L2w\n8Fal/mPeYwKBgE89dl0pmpRv19zR+iaLN0zrZo3rR/83AHHCCBwGGui7L9ZZThPR\nxtTwRaqomgfU0JnNAHafh6TxVvn0bNCphe2HuJyHoPK9wWR1yXNiRrarDBHmLAvU\nGxwXfLWyLTs10mdzU98+x37+2/oc5Br4FGJQhAHjLg2sa9UpTHTlXLVJAoGBAMi2\n6xKajJrXDuvAN8o5F9jlW6X1KCsY7MoH6gSzkYP3i5bbileO/OCjkYiXl+VwK9Aa\nlbwES6d/QM+SlNXHAtACi+9cjfApv4Z54NY30pv8607iJ3XegyUy74qJuDtI1s1U\nm9w/Hugbv7LvOlG40fofL1mtPOzEzoveciPtZJMzAoGBAMk++690xWQr8oWxxpDN\ntUkTpBwoeZ0VQx1E4w6B5XASjikmsblnpO+N1BwqDER+PsPw7B3gT9edhpUJf8TL\nlF4tin8Q9huqjjVdeUd2FxtVScNiyBO6UUtUgC1MtYKIox0saKfwX2DmAemqe9n+\nC0t9w6x0/XK4hZ5Vklp26/dS\n-----END PRIVATE KEY-----\n",
+  "client_email": "mcp-939@ninjacross.iam.gserviceaccount.com",
+  "client_id": "101546098649994814214",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/mcp-939%40ninjacross.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..c4f9bd3
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,7461 @@
+{
+  "name": "lizenz-generator",
+  "version": "1.0.0",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "lizenz-generator",
+      "version": "1.0.0",
+      "license": "propriatary",
+      "dependencies": {
+        "@hisma/server-puppeteer": "^0.6.5",
+        "bcrypt": "^5.1.1",
+        "discord-oauth2": "^2.12.1",
+        "dotenv": "^16.3.1",
+        "enhanced-postgres-mcp-server": "^1.0.1",
+        "express": "^4.18.2",
+        "express-session": "^1.17.3",
+        "https": "^1.0.0",
+        "node-cron": "^4.2.1",
+        "passport": "^0.7.0",
+        "passport-discord": "^0.1.4",
+        "pg": "^8.11.3",
+        "socket.io": "^4.8.1",
+        "swagger-jsdoc": "^6.2.8",
+        "swagger-ui-express": "^5.0.1",
+        "uuid": "^12.0.0",
+        "web-push": "^3.6.7"
+      },
+      "devDependencies": {
+        "nodemon": "^3.0.1"
+      }
+    },
+    "node_modules/@apidevtools/json-schema-ref-parser": {
+      "version": "9.1.2",
+      "resolved": "https://registry.npmjs.org/@apidevtools/json-schema-ref-parser/-/json-schema-ref-parser-9.1.2.tgz",
+      "integrity": "sha512-r1w81DpR+KyRWd3f+rk6TNqMgedmAxZP5v5KWlXQWlgMUUtyEJch0DKEci1SorPMiSeM8XPl7MZ3miJ60JIpQg==",
+      "license": "MIT",
+      "dependencies": {
+        "@jsdevtools/ono": "^7.1.3",
+        "@types/json-schema": "^7.0.6",
+        "call-me-maybe": "^1.0.1",
+        "js-yaml": "^4.1.0"
+      }
+    },
+    "node_modules/@apidevtools/openapi-schemas": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@apidevtools/openapi-schemas/-/openapi-schemas-2.1.0.tgz",
+      "integrity": "sha512-Zc1AlqrJlX3SlpupFGpiLi2EbteyP7fXmUOGup6/DnkRgjP9bgMM/ag+n91rsv0U1Gpz0H3VILA/o3bW7Ua6BQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@apidevtools/swagger-methods": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@apidevtools/swagger-methods/-/swagger-methods-3.0.2.tgz",
+      "integrity": "sha512-QAkD5kK2b1WfjDS/UQn/qQkbwF31uqRjPTrsCs5ZG9BQGAkjwvqGFjjPqAuzac/IYzpPtRzjCP1WrTuAIjMrXg==",
+      "license": "MIT"
+    },
+    "node_modules/@apidevtools/swagger-parser": {
+      "version": "10.0.3",
+      "resolved": "https://registry.npmjs.org/@apidevtools/swagger-parser/-/swagger-parser-10.0.3.tgz",
+      "integrity": "sha512-sNiLY51vZOmSPFZA5TF35KZ2HbgYklQnTSDnkghamzLb3EkNtcQnrBQEj5AOCxHpTtXpqMCRM1CrmV2rG6nw4g==",
+      "license": "MIT",
+      "dependencies": {
+        "@apidevtools/json-schema-ref-parser": "^9.0.6",
+        "@apidevtools/openapi-schemas": "^2.0.4",
+        "@apidevtools/swagger-methods": "^3.0.2",
+        "@jsdevtools/ono": "^7.1.3",
+        "call-me-maybe": "^1.0.1",
+        "z-schema": "^5.0.1"
+      },
+      "peerDependencies": {
+        "openapi-types": ">=7"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.27.1",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+      "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer": {
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/@hisma/server-puppeteer/-/server-puppeteer-0.6.5.tgz",
+      "integrity": "sha512-D8U2Va5Ay7MISKBdC4o8R/5w7VX24ZhqdoyTpxnxSOPL7IeedDeV2/18eCauvfa59g5p0aD+VwVN7JEpcWALXg==",
+      "license": "MIT",
+      "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.13.2",
+        "puppeteer": "^24.11.0"
+      },
+      "bin": {
+        "mcp-server-puppeteer": "dist/index.js"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/@modelcontextprotocol/sdk": {
+      "version": "1.17.4",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.17.4.tgz",
+      "integrity": "sha512-zq24hfuAmmlNZvik0FLI58uE5sriN0WWsQzIlYnzSuKDAHFqJtBFrl/LfB1NLgJT5Y7dEBzaX4yAKqOPrcetaw==",
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^6.12.6",
+        "content-type": "^1.0.5",
+        "cors": "^2.8.5",
+        "cross-spawn": "^7.0.5",
+        "eventsource": "^3.0.2",
+        "eventsource-parser": "^3.0.0",
+        "express": "^5.0.1",
+        "express-rate-limit": "^7.5.0",
+        "pkce-challenge": "^5.0.0",
+        "raw-body": "^3.0.0",
+        "zod": "^3.23.8",
+        "zod-to-json-schema": "^3.24.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/accepts": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
+      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "^3.0.0",
+        "negotiator": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/body-parser": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.0.tgz",
+      "integrity": "sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "^3.1.2",
+        "content-type": "^1.0.5",
+        "debug": "^4.4.0",
+        "http-errors": "^2.0.0",
+        "iconv-lite": "^0.6.3",
+        "on-finished": "^2.4.1",
+        "qs": "^6.14.0",
+        "raw-body": "^3.0.0",
+        "type-is": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/content-disposition": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.0.tgz",
+      "integrity": "sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/cookie-signature": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
+      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.6.0"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/express": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/express/-/express-5.1.0.tgz",
+      "integrity": "sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "^2.0.0",
+        "body-parser": "^2.2.0",
+        "content-disposition": "^1.0.0",
+        "content-type": "^1.0.5",
+        "cookie": "^0.7.1",
+        "cookie-signature": "^1.2.1",
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "finalhandler": "^2.1.0",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "merge-descriptors": "^2.0.0",
+        "mime-types": "^3.0.0",
+        "on-finished": "^2.4.1",
+        "once": "^1.4.0",
+        "parseurl": "^1.3.3",
+        "proxy-addr": "^2.0.7",
+        "qs": "^6.14.0",
+        "range-parser": "^1.2.1",
+        "router": "^2.2.0",
+        "send": "^1.1.0",
+        "serve-static": "^2.2.0",
+        "statuses": "^2.0.1",
+        "type-is": "^2.0.1",
+        "vary": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/finalhandler": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.0.tgz",
+      "integrity": "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "on-finished": "^2.4.1",
+        "parseurl": "^1.3.3",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/fresh": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
+      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/media-typer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
+      "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/merge-descriptors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
+      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/mime-types": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.1.tgz",
+      "integrity": "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "^1.54.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/negotiator": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
+      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/qs": {
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz",
+      "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "side-channel": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/raw-body": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.0.tgz",
+      "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.6.3",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/send": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz",
+      "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.3.5",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "mime-types": "^3.0.1",
+        "ms": "^2.1.3",
+        "on-finished": "^2.4.1",
+        "range-parser": "^1.2.1",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/serve-static": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.0.tgz",
+      "integrity": "sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "parseurl": "^1.3.3",
+        "send": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@hisma/server-puppeteer/node_modules/type-is": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz",
+      "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==",
+      "license": "MIT",
+      "dependencies": {
+        "content-type": "^1.0.5",
+        "media-typer": "^1.1.0",
+        "mime-types": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@jsdevtools/ono": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/@jsdevtools/ono/-/ono-7.1.3.tgz",
+      "integrity": "sha512-4JQNk+3mVzK3xh2rqd6RB4J46qUR19azEHBneZyTZM+c456qOrbbM/5xcR8huNCCcbVt7+UmizG6GuUvPvKUYg==",
+      "license": "MIT"
+    },
+    "node_modules/@mapbox/node-pre-gyp": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/@mapbox/node-pre-gyp/-/node-pre-gyp-1.0.11.tgz",
+      "integrity": "sha512-Yhlar6v9WQgUp/He7BdgzOz8lqMQ8sU+jkCq7Wx8Myc5YFJLbEe7lgui/V7G1qB1DJykHSGwreceSaD60Y0PUQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "detect-libc": "^2.0.0",
+        "https-proxy-agent": "^5.0.0",
+        "make-dir": "^3.1.0",
+        "node-fetch": "^2.6.7",
+        "nopt": "^5.0.0",
+        "npmlog": "^5.0.1",
+        "rimraf": "^3.0.2",
+        "semver": "^7.3.5",
+        "tar": "^6.1.11"
+      },
+      "bin": {
+        "node-pre-gyp": "bin/node-pre-gyp"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.0.1.tgz",
+      "integrity": "sha512-slLdFaxQJ9AlRg+hw28iiTtGvShAOgOKXcD0F91nUcRYiOMuS9ZBYjcdNZRXW9G5JQ511GRTdUy1zQVZDpJ+4w==",
+      "license": "MIT",
+      "dependencies": {
+        "content-type": "^1.0.5",
+        "raw-body": "^3.0.0",
+        "zod": "^3.23.8"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/raw-body": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.0.tgz",
+      "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.6.3",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/@puppeteer/browsers": {
+      "version": "2.10.8",
+      "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.10.8.tgz",
+      "integrity": "sha512-f02QYEnBDE0p8cteNoPYHHjbDuwyfbe4cCIVlNi8/MRicIxFW4w4CfgU0LNgWEID6s06P+hRJ1qjpBLMhPRCiQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "debug": "^4.4.1",
+        "extract-zip": "^2.0.1",
+        "progress": "^2.0.3",
+        "proxy-agent": "^6.5.0",
+        "semver": "^7.7.2",
+        "tar-fs": "^3.1.0",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "browsers": "lib/cjs/main-cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@puppeteer/browsers/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@puppeteer/browsers/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/@scarf/scarf": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/@scarf/scarf/-/scarf-1.4.0.tgz",
+      "integrity": "sha512-xxeapPiUXdZAE3che6f3xogoJPeZgig6omHEy1rIY5WVsB3H2BHNnZH+gHG6x91SCWyQCzWGsuL2Hh3ClO5/qQ==",
+      "hasInstallScript": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/@socket.io/component-emitter": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@socket.io/component-emitter/-/component-emitter-3.1.2.tgz",
+      "integrity": "sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA==",
+      "license": "MIT"
+    },
+    "node_modules/@tootallnate/quickjs-emscripten": {
+      "version": "0.23.0",
+      "resolved": "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz",
+      "integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/cors": {
+      "version": "2.8.19",
+      "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
+      "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "24.3.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.3.0.tgz",
+      "integrity": "sha512-aPTXCrfwnDLj4VvXrm+UUCQjNEvJgNA8s5F1cvwQU+3KNltTOkBm1j30uNLyqqPNe7gE3KFzImYoZEfLhp4Yow==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.10.0"
+      }
+    },
+    "node_modules/@types/yauzl": {
+      "version": "2.10.3",
+      "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
+      "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/abbrev": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
+      "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==",
+      "license": "ISC"
+    },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/agent-base": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
+      "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/agent-base/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/agent-base/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/aproba": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.1.0.tgz",
+      "integrity": "sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew==",
+      "license": "ISC"
+    },
+    "node_modules/are-we-there-yet": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-2.0.0.tgz",
+      "integrity": "sha512-Ci/qENmwHnsYo9xKIcUJN5LeDKdJ6R1Z1j9V/J5wyq8nh/mYPEpIKJbBZXtZjG04HiK7zV/p6Vs9952MrMeUIw==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "delegates": "^1.0.0",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "license": "Python-2.0"
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg=="
+    },
+    "node_modules/asn1.js": {
+      "version": "5.4.1",
+      "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-5.4.1.tgz",
+      "integrity": "sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==",
+      "license": "MIT",
+      "dependencies": {
+        "bn.js": "^4.0.0",
+        "inherits": "^2.0.1",
+        "minimalistic-assert": "^1.0.0",
+        "safer-buffer": "^2.1.0"
+      }
+    },
+    "node_modules/ast-types": {
+      "version": "0.13.4",
+      "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.13.4.tgz",
+      "integrity": "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/b4a": {
+      "version": "1.6.7",
+      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.7.tgz",
+      "integrity": "sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
+    },
+    "node_modules/bare-events": {
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.6.1.tgz",
+      "integrity": "sha512-AuTJkq9XmE6Vk0FJVNq5QxETrSA/vKHarWVBG5l/JbdCL1prJemiyJqUS0jrlXO0MftuPq4m3YVYhoNc5+aE/g==",
+      "license": "Apache-2.0",
+      "optional": true
+    },
+    "node_modules/bare-fs": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.2.2.tgz",
+      "integrity": "sha512-5vn+bdnlCYMwETIm1FqQXDP6TYPbxr2uJd88ve40kr4oPbiTZJVrTNzqA3/4sfWZeWKuQR/RkboBt7qEEDtfMA==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "bare-events": "^2.5.4",
+        "bare-path": "^3.0.0",
+        "bare-stream": "^2.6.4"
+      },
+      "engines": {
+        "bare": ">=1.16.0"
+      },
+      "peerDependencies": {
+        "bare-buffer": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-buffer": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-os": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.2.tgz",
+      "integrity": "sha512-T+V1+1srU2qYNBmJCXZkUY5vQ0B4FSlL3QDROnKQYOqeiQR8UbjNHlPa+TIbM4cuidiN9GaTaOZgSEgsvPbh5A==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "engines": {
+        "bare": ">=1.14.0"
+      }
+    },
+    "node_modules/bare-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.0.tgz",
+      "integrity": "sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "bare-os": "^3.0.1"
+      }
+    },
+    "node_modules/bare-stream": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.7.0.tgz",
+      "integrity": "sha512-oyXQNicV1y8nc2aKffH+BUHFRXmx6VrPzlnaEvMhram0nPBrKcEdcyBg5r08D0i8VxngHFAiVyn1QKXpSG0B8A==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "streamx": "^2.21.0"
+      },
+      "peerDependencies": {
+        "bare-buffer": "*",
+        "bare-events": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-buffer": {
+          "optional": true
+        },
+        "bare-events": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/base64id": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/base64id/-/base64id-2.0.0.tgz",
+      "integrity": "sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog==",
+      "license": "MIT",
+      "engines": {
+        "node": "^4.5.0 || >= 5.9"
+      }
+    },
+    "node_modules/base64url": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/base64url/-/base64url-3.0.1.tgz",
+      "integrity": "sha512-ir1UPr3dkwexU7FdV8qBBbNDRUhMmIekYMFZfi+C/sLNnRESKPl23nB9b2pltqfOQNnGzsDdId90AEtG5tCx4A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/basic-ftp": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.0.5.tgz",
+      "integrity": "sha512-4Bcg1P8xhUuqcii/S0Z9wiHIrQVPMermM1any+MX5GeGD7faD3/msQUDGLol9wOcz4/jbg/WJnGqoJF6LiBdtg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/bcrypt": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/bcrypt/-/bcrypt-5.1.1.tgz",
+      "integrity": "sha512-AGBHOG5hPYZ5Xl9KXzU5iKq9516yEmvCKDg3ecP5kX2aB6UqTeXZxk2ELnDgDm6BQSMlLt9rDB4LoSMx0rYwww==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "@mapbox/node-pre-gyp": "^1.0.11",
+        "node-addon-api": "^5.0.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/bn.js": {
+      "version": "4.12.2",
+      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.2.tgz",
+      "integrity": "sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw==",
+      "license": "MIT"
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.3",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
+      "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "on-finished": "2.4.1",
+        "qs": "6.13.0",
+        "raw-body": "2.5.2",
+        "type-is": "~1.6.18",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/buffer-crc32": {
+      "version": "0.2.13",
+      "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+      "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/buffer-equal-constant-time": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
+      "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/call-me-maybe": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-me-maybe/-/call-me-maybe-1.0.2.tgz",
+      "integrity": "sha512-HpX65o1Hnr9HH25ojC1YGs7HCQLq0GCOibSaWER0eNpgJ/Z1MZv2mTc7+xh6WOPxbRVcmgbv4hGU+uSQ/2xFZQ==",
+      "license": "MIT"
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/chownr": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz",
+      "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/chromium-bidi": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-8.0.0.tgz",
+      "integrity": "sha512-d1VmE0FD7lxZQHzcDUCKZSNRtRwISXDsdg4HjdTR5+Ll5nQ/vzU12JeNmupD6VWffrPSlrnGhEWlLESKH3VO+g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "mitt": "^3.0.1",
+        "zod": "^3.24.1"
+      },
+      "peerDependencies": {
+        "devtools-protocol": "*"
+      }
+    },
+    "node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
+    "node_modules/color-support": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz",
+      "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==",
+      "license": "ISC",
+      "bin": {
+        "color-support": "bin.js"
+      }
+    },
+    "node_modules/commander": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-6.2.0.tgz",
+      "integrity": "sha512-zP4jEKbe8SHzKJYQmq8Y9gYjtO/POJLgIdKgV7B9qNmABVFVc+ctqSX6iXh4mCpJfRBOabiZ2YKPg8ciDw6C+Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="
+    },
+    "node_modules/console-control-strings": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz",
+      "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==",
+      "license": "ISC"
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
+      "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ=="
+    },
+    "node_modules/cors": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
+      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/cosmiconfig": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-9.0.0.tgz",
+      "integrity": "sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==",
+      "license": "MIT",
+      "dependencies": {
+        "env-paths": "^2.2.1",
+        "import-fresh": "^3.3.0",
+        "js-yaml": "^4.1.0",
+        "parse-json": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/d-fischer"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.9.5"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/data-uri-to-buffer": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz",
+      "integrity": "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/degenerator": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/degenerator/-/degenerator-5.0.1.tgz",
+      "integrity": "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ast-types": "^0.13.4",
+        "escodegen": "^2.1.0",
+        "esprima": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/delegates": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz",
+      "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==",
+      "license": "MIT"
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.4.tgz",
+      "integrity": "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/devtools-protocol": {
+      "version": "0.0.1475386",
+      "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1475386.tgz",
+      "integrity": "sha512-RQ809ykTfJ+dgj9bftdeL2vRVxASAuGU+I9LEx9Ij5TXU5HrgAQVmzi72VA+mkzscE12uzlRv5/tWWv9R9J1SA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/discord-oauth2": {
+      "version": "2.12.1",
+      "resolved": "https://registry.npmjs.org/discord-oauth2/-/discord-oauth2-2.12.1.tgz",
+      "integrity": "sha512-/Um39bRxVjcGHUu1YaTLangZvZveXjsX4BNsa1Iyd6OQG0jL972IBQGKD0mYqQswxC3bT+hqWSouabfI2RdaZA==",
+      "license": "MIT"
+    },
+    "node_modules/doctrine": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
+      "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "esutils": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.5.0",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.5.0.tgz",
+      "integrity": "sha512-m/C+AwOAr9/W1UOIZUo232ejMNnJAJtYQjUbHoNTBNTJSvqzzDh7vnrei3o3r3m9blf6ZoDkvcw0VmozNRFJxg==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ecdsa-sig-formatter": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
+      "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/end-of-stream": {
+      "version": "1.4.5",
+      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+      "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+      "license": "MIT",
+      "dependencies": {
+        "once": "^1.4.0"
+      }
+    },
+    "node_modules/engine.io": {
+      "version": "6.6.4",
+      "resolved": "https://registry.npmjs.org/engine.io/-/engine.io-6.6.4.tgz",
+      "integrity": "sha512-ZCkIjSYNDyGn0R6ewHDtXgns/Zre/NT6Agvq1/WobF7JXgFff4SeDroKiCO3fNJreU9YG429Sc81o4w5ok/W5g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/cors": "^2.8.12",
+        "@types/node": ">=10.0.0",
+        "accepts": "~1.3.4",
+        "base64id": "2.0.0",
+        "cookie": "~0.7.2",
+        "cors": "~2.8.5",
+        "debug": "~4.3.1",
+        "engine.io-parser": "~5.2.1",
+        "ws": "~8.17.1"
+      },
+      "engines": {
+        "node": ">=10.2.0"
+      }
+    },
+    "node_modules/engine.io-parser": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/engine.io-parser/-/engine.io-parser-5.2.3.tgz",
+      "integrity": "sha512-HqD3yTBfnBxIrbnM1DoD6Pcq8NECnh8d4As1Qgh0z5Gg3jRRIqijury0CL3ghu/edArpUYiYqQiDUQBIs4np3Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/engine.io/node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/engine.io/node_modules/debug": {
+      "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/engine.io/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/engine.io/node_modules/ws": {
+      "version": "8.17.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz",
+      "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/enhanced-postgres-mcp-server": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/enhanced-postgres-mcp-server/-/enhanced-postgres-mcp-server-1.0.1.tgz",
+      "integrity": "sha512-tw7GJbrgdwrNl0ZEYuytNfEwNBNqplpGCwMN3mJ3okqEl9xm3c1Dft/5N38YwUxmkAQbK86eiA6Fq95dR/2f9A==",
+      "license": "MIT",
+      "dependencies": {
+        "@modelcontextprotocol/sdk": "1.0.1",
+        "pg": "^8.13.0"
+      },
+      "bin": {
+        "enhanced-postgres-mcp": "dist/index.js"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/env-paths": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
+      "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/error-ex": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
+      "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
+      "license": "MIT",
+      "dependencies": {
+        "is-arrayish": "^0.2.1"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="
+    },
+    "node_modules/escodegen": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz",
+      "integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esprima": "^4.0.1",
+        "estraverse": "^5.2.0",
+        "esutils": "^2.0.2"
+      },
+      "bin": {
+        "escodegen": "bin/escodegen.js",
+        "esgenerate": "bin/esgenerate.js"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "optionalDependencies": {
+        "source-map": "~0.6.1"
+      }
+    },
+    "node_modules/esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "license": "BSD-2-Clause",
+      "bin": {
+        "esparse": "bin/esparse.js",
+        "esvalidate": "bin/esvalidate.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/eventsource": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz",
+      "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==",
+      "license": "MIT",
+      "dependencies": {
+        "eventsource-parser": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/eventsource-parser": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.6.tgz",
+      "integrity": "sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.21.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
+      "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "1.20.3",
+        "content-disposition": "0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "0.7.1",
+        "cookie-signature": "1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "1.3.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "merge-descriptors": "1.0.3",
+        "methods": "~1.1.2",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "0.1.12",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.13.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "0.19.0",
+        "serve-static": "1.16.2",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/express-rate-limit": {
+      "version": "7.5.1",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.1.tgz",
+      "integrity": "sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/express-rate-limit"
+      },
+      "peerDependencies": {
+        "express": ">= 4.11"
+      }
+    },
+    "node_modules/express-session": {
+      "version": "1.18.2",
+      "resolved": "https://registry.npmjs.org/express-session/-/express-session-1.18.2.tgz",
+      "integrity": "sha512-SZjssGQC7TzTs9rpPDuUrR23GNZ9+2+IkA/+IJWmvQilTr5OSliEHGF+D9scbIpdC6yGtTI0/VhaHoVes2AN/A==",
+      "license": "MIT",
+      "dependencies": {
+        "cookie": "0.7.2",
+        "cookie-signature": "1.0.7",
+        "debug": "2.6.9",
+        "depd": "~2.0.0",
+        "on-headers": "~1.1.0",
+        "parseurl": "~1.3.3",
+        "safe-buffer": "5.2.1",
+        "uid-safe": "~2.1.5"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/express-session/node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express-session/node_modules/cookie-signature": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.7.tgz",
+      "integrity": "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==",
+      "license": "MIT"
+    },
+    "node_modules/extract-zip": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
+      "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "debug": "^4.1.1",
+        "get-stream": "^5.1.0",
+        "yauzl": "^2.10.0"
+      },
+      "bin": {
+        "extract-zip": "cli.js"
+      },
+      "engines": {
+        "node": ">= 10.17.0"
+      },
+      "optionalDependencies": {
+        "@types/yauzl": "^2.9.1"
+      }
+    },
+    "node_modules/extract-zip/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/extract-zip/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "license": "MIT"
+    },
+    "node_modules/fast-fifo": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
+      "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==",
+      "license": "MIT"
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "license": "MIT"
+    },
+    "node_modules/fd-slicer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
+      "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
+      "license": "MIT",
+      "dependencies": {
+        "pend": "~1.2.0"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/finalhandler": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz",
+      "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "2.0.1",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fs-minipass": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",
+      "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/fs-minipass/node_modules/minipass": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "license": "ISC"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/gauge": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/gauge/-/gauge-3.0.2.tgz",
+      "integrity": "sha512-+5J6MS/5XksCuXq++uFRsnUd7Ovu1XenbeuIuNRJxYWjgQbPuFhT14lAvsWfqfAmnwluf1OwMjz39HjfLPci0Q==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "aproba": "^1.0.3 || ^2.0.0",
+        "color-support": "^1.1.2",
+        "console-control-strings": "^1.0.0",
+        "has-unicode": "^2.0.1",
+        "object-assign": "^4.1.1",
+        "signal-exit": "^3.0.0",
+        "string-width": "^4.2.3",
+        "strip-ansi": "^6.0.1",
+        "wide-align": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/get-stream": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
+      "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
+      "license": "MIT",
+      "dependencies": {
+        "pump": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/get-uri": {
+      "version": "6.0.5",
+      "resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.5.tgz",
+      "integrity": "sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg==",
+      "license": "MIT",
+      "dependencies": {
+        "basic-ftp": "^5.0.2",
+        "data-uri-to-buffer": "^6.0.2",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/get-uri/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/get-uri/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+      "dev": true,
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-unicode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz",
+      "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==",
+      "license": "ISC"
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/http_ece": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/http_ece/-/http_ece-1.2.0.tgz",
+      "integrity": "sha512-JrF8SSLVmcvc5NducxgyOrKXe3EsyHMgBFgSaIUGmArKe+rwr0uphRkRXvwiom3I+fpIfoItveHrfudL8/rxuA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/http-proxy-agent": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/http-proxy-agent/node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/http-proxy-agent/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/http-proxy-agent/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/https": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/https/-/https-1.0.0.tgz",
+      "integrity": "sha512-4EC57ddXrkaF0x83Oj8sM6SLQHAWXw90Skqu2M4AEWENZ3F02dFJE/GARA8igO79tcgYqGrD7ae4f5L3um2lgg==",
+      "license": "ISC"
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
+      "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "6",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/https-proxy-agent/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/https-proxy-agent/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/ignore-by-default": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/ignore-by-default/-/ignore-by-default-1.0.1.tgz",
+      "integrity": "sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==",
+      "dev": true
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+      "license": "MIT",
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+      "license": "ISC",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+    },
+    "node_modules/ip-address": {
+      "version": "10.0.1",
+      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.0.1.tgz",
+      "integrity": "sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-arrayish": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
+      "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
+      "license": "MIT"
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/is-promise": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
+      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
+      "license": "MIT"
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "license": "ISC"
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/json-parse-even-better-errors": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
+      "license": "MIT"
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "license": "MIT"
+    },
+    "node_modules/jwa": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
+      "integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-equal-constant-time": "^1.0.1",
+        "ecdsa-sig-formatter": "1.0.11",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/jws": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.0.tgz",
+      "integrity": "sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg==",
+      "license": "MIT",
+      "dependencies": {
+        "jwa": "^2.0.0",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/lines-and-columns": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.get": {
+      "version": "4.4.2",
+      "resolved": "https://registry.npmjs.org/lodash.get/-/lodash.get-4.4.2.tgz",
+      "integrity": "sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==",
+      "deprecated": "This package is deprecated. Use the optional chaining (?.) operator instead.",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isequal": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
+      "integrity": "sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==",
+      "deprecated": "This package is deprecated. Use require('node:util').isDeepStrictEqual instead.",
+      "license": "MIT"
+    },
+    "node_modules/lodash.mergewith": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.mergewith/-/lodash.mergewith-4.6.2.tgz",
+      "integrity": "sha512-GK3g5RPZWTRSeLSpgP8Xhra+pnjBC56q9FZYe1d5RN3TJ35dbkGy3YqBSMbyCrlbi+CM9Z3Jk5yTL7RCsqboyQ==",
+      "license": "MIT"
+    },
+    "node_modules/lru-cache": {
+      "version": "7.18.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+      "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/make-dir": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
+      "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/make-dir/node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimalistic-assert": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz",
+      "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==",
+      "license": "ISC"
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz",
+      "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/minizlib": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz",
+      "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==",
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^3.0.0",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/minizlib/node_modules/minipass": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/mitt": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
+      "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==",
+      "license": "MIT"
+    },
+    "node_modules/mkdirp": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
+      "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
+      "license": "MIT",
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/netmask": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/netmask/-/netmask-2.0.2.tgz",
+      "integrity": "sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/node-addon-api": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-5.1.0.tgz",
+      "integrity": "sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA==",
+      "license": "MIT"
+    },
+    "node_modules/node-cron": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/node-cron/-/node-cron-4.2.1.tgz",
+      "integrity": "sha512-lgimEHPE/QDgFlywTd8yTR61ptugX3Qer29efeyWw2rv259HtGBNn1vZVmp8lB9uo9wC0t/AT4iGqXxia+CJFg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/nodemon": {
+      "version": "3.1.10",
+      "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.10.tgz",
+      "integrity": "sha512-WDjw3pJ0/0jMFmyNDp3gvY2YizjLmmOUQo6DEBY+JgdvW/yQ9mEeSw6H5ythl5Ny2ytb7f9C2nIbjSxMNzbJXw==",
+      "dev": true,
+      "dependencies": {
+        "chokidar": "^3.5.2",
+        "debug": "^4",
+        "ignore-by-default": "^1.0.1",
+        "minimatch": "^3.1.2",
+        "pstree.remy": "^1.1.8",
+        "semver": "^7.5.3",
+        "simple-update-notifier": "^2.0.0",
+        "supports-color": "^5.5.0",
+        "touch": "^3.1.0",
+        "undefsafe": "^2.0.5"
+      },
+      "bin": {
+        "nodemon": "bin/nodemon.js"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/nodemon"
+      }
+    },
+    "node_modules/nodemon/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "dev": true,
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/nodemon/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true
+    },
+    "node_modules/nopt": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz",
+      "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==",
+      "license": "ISC",
+      "dependencies": {
+        "abbrev": "1"
+      },
+      "bin": {
+        "nopt": "bin/nopt.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/npmlog": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-5.0.1.tgz",
+      "integrity": "sha512-AqZtDUWOMKs1G/8lwylVjrdYgqA4d9nu8hc+0gzRxlDb1I10+FHBGMXs6aiQHFdCUUlqH99MUMuLfzWDNDtfxw==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "are-we-there-yet": "^2.0.0",
+        "console-control-strings": "^1.1.0",
+        "gauge": "^3.0.0",
+        "set-blocking": "^2.0.0"
+      }
+    },
+    "node_modules/oauth": {
+      "version": "0.10.2",
+      "resolved": "https://registry.npmjs.org/oauth/-/oauth-0.10.2.tgz",
+      "integrity": "sha512-JtFnB+8nxDEXgNyniwz573xxbKSOu3R8D40xQKqcjwJ2CDkYqUDI53o6IuzDJBx60Z8VKCm271+t8iFjakrl8Q==",
+      "license": "MIT"
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/on-headers": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.1.0.tgz",
+      "integrity": "sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "license": "ISC",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/openapi-types": {
+      "version": "12.1.3",
+      "resolved": "https://registry.npmjs.org/openapi-types/-/openapi-types-12.1.3.tgz",
+      "integrity": "sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/pac-proxy-agent": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.2.0.tgz",
+      "integrity": "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==",
+      "license": "MIT",
+      "dependencies": {
+        "@tootallnate/quickjs-emscripten": "^0.23.0",
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "get-uri": "^6.0.1",
+        "http-proxy-agent": "^7.0.0",
+        "https-proxy-agent": "^7.0.6",
+        "pac-resolver": "^7.0.1",
+        "socks-proxy-agent": "^8.0.5"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/pac-proxy-agent/node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/pac-proxy-agent/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/pac-proxy-agent/node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/pac-proxy-agent/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/pac-resolver": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/pac-resolver/-/pac-resolver-7.0.1.tgz",
+      "integrity": "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==",
+      "license": "MIT",
+      "dependencies": {
+        "degenerator": "^5.0.0",
+        "netmask": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "license": "MIT",
+      "dependencies": {
+        "callsites": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/parse-json": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
+      "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.0.0",
+        "error-ex": "^1.3.1",
+        "json-parse-even-better-errors": "^2.3.0",
+        "lines-and-columns": "^1.1.6"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/passport": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/passport/-/passport-0.7.0.tgz",
+      "integrity": "sha512-cPLl+qZpSc+ireUvt+IzqbED1cHHkDoVYMo30jbJIdOOjQ1MQYZBPiNvmi8UM6lJuOpTPXJGZQk0DtC4y61MYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "passport-strategy": "1.x.x",
+        "pause": "0.0.1",
+        "utils-merge": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/jaredhanson"
+      }
+    },
+    "node_modules/passport-discord": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/passport-discord/-/passport-discord-0.1.4.tgz",
+      "integrity": "sha512-VJWPYqSOmh7SaCLw/C+k1ZqCzJnn2frrmQRx1YrcPJ3MQ+Oa31XclbbmqFICSvl8xv3Fqd6YWQ4H4p1MpIN9rA==",
+      "license": "ISC",
+      "dependencies": {
+        "passport-oauth2": "^1.5.0"
+      }
+    },
+    "node_modules/passport-oauth2": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/passport-oauth2/-/passport-oauth2-1.8.0.tgz",
+      "integrity": "sha512-cjsQbOrXIDE4P8nNb3FQRCCmJJ/utnFKEz2NX209f7KOHPoX18gF7gBzBbLLsj2/je4KrgiwLLGjf0lm9rtTBA==",
+      "license": "MIT",
+      "dependencies": {
+        "base64url": "3.x.x",
+        "oauth": "0.10.x",
+        "passport-strategy": "1.x.x",
+        "uid2": "0.0.x",
+        "utils-merge": "1.x.x"
+      },
+      "engines": {
+        "node": ">= 0.4.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/jaredhanson"
+      }
+    },
+    "node_modules/passport-strategy": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/passport-strategy/-/passport-strategy-1.0.0.tgz",
+      "integrity": "sha512-CB97UUvDKJde2V0KDWWB3lyf6PC3FaZP7YxZ2G8OAtn9p4HI9j9JLP9qjOGZFvyl8uwNT8qM+hGnz/n16NI7oA==",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.12",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
+      "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ=="
+    },
+    "node_modules/pause": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/pause/-/pause-0.0.1.tgz",
+      "integrity": "sha512-KG8UEiEVkR3wGEb4m5yZkVCzigAD+cVEJck2CzYZO37ZGJfctvVptVO192MwrtPhzONn6go8ylnOdMhKqi4nfg=="
+    },
+    "node_modules/pend": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
+      "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
+      "license": "MIT"
+    },
+    "node_modules/pg": {
+      "version": "8.16.0",
+      "resolved": "https://registry.npmjs.org/pg/-/pg-8.16.0.tgz",
+      "integrity": "sha512-7SKfdvP8CTNXjMUzfcVTaI+TDzBEeaUnVwiVGZQD1Hh33Kpev7liQba9uLd4CfN8r9mCVsD0JIpq03+Unpz+kg==",
+      "dependencies": {
+        "pg-connection-string": "^2.9.0",
+        "pg-pool": "^3.10.0",
+        "pg-protocol": "^1.10.0",
+        "pg-types": "2.2.0",
+        "pgpass": "1.0.5"
+      },
+      "engines": {
+        "node": ">= 8.0.0"
+      },
+      "optionalDependencies": {
+        "pg-cloudflare": "^1.2.5"
+      },
+      "peerDependencies": {
+        "pg-native": ">=3.0.1"
+      },
+      "peerDependenciesMeta": {
+        "pg-native": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/pg-cloudflare": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.2.5.tgz",
+      "integrity": "sha512-OOX22Vt0vOSRrdoUPKJ8Wi2OpE/o/h9T8X1s4qSkCedbNah9ei2W2765be8iMVxQUsvgT7zIAT2eIa9fs5+vtg==",
+      "optional": true
+    },
+    "node_modules/pg-connection-string": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.9.0.tgz",
+      "integrity": "sha512-P2DEBKuvh5RClafLngkAuGe9OUlFV7ebu8w1kmaaOgPcpJd1RIFh7otETfI6hAR8YupOLFTY7nuvvIn7PLciUQ=="
+    },
+    "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==",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/pg-pool": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.10.0.tgz",
+      "integrity": "sha512-DzZ26On4sQ0KmqnO34muPcmKbhrjmyiO4lCCR0VwEd7MjmiKf5NTg/6+apUEu0NF7ESa37CGzFxH513CoUmWnA==",
+      "peerDependencies": {
+        "pg": ">=8.0"
+      }
+    },
+    "node_modules/pg-protocol": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.10.0.tgz",
+      "integrity": "sha512-IpdytjudNuLv8nhlHs/UrVBhU0e78J0oIS/0AVdTbWxSOkFUVdsHC/NrorO6nXsQNDTT1kzDSOMJubBQviX18Q=="
+    },
+    "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==",
+      "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==",
+      "dependencies": {
+        "split2": "^4.1.0"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/pkce-challenge": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.0.tgz",
+      "integrity": "sha512-ueGLflrrnvwB3xuo/uGob5pd5FN7l0MsLf0Z87o/UQmRtwjvfylfc9MurIxRAWywCYTgrvpXBcqjV4OfCYGCIQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.20.0"
+      }
+    },
+    "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==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postgres-bytea": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.0.tgz",
+      "integrity": "sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w==",
+      "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==",
+      "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==",
+      "dependencies": {
+        "xtend": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/progress": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
+      "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/proxy-agent": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.5.0.tgz",
+      "integrity": "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "http-proxy-agent": "^7.0.1",
+        "https-proxy-agent": "^7.0.6",
+        "lru-cache": "^7.14.1",
+        "pac-proxy-agent": "^7.1.0",
+        "proxy-from-env": "^1.1.0",
+        "socks-proxy-agent": "^8.0.5"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/proxy-agent/node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/proxy-agent/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/proxy-agent/node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/proxy-agent/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
+    "node_modules/pstree.remy": {
+      "version": "1.1.8",
+      "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz",
+      "integrity": "sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==",
+      "dev": true
+    },
+    "node_modules/pump": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
+      "integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==",
+      "license": "MIT",
+      "dependencies": {
+        "end-of-stream": "^1.1.0",
+        "once": "^1.3.1"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/puppeteer": {
+      "version": "24.18.0",
+      "resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-24.18.0.tgz",
+      "integrity": "sha512-Ke8oL/87GhzKIM2Ag6Yj49t5xbGc4rspGIuSuFLFCQBtYzWqCSanvqoCu08WkI78rbqcwnHjxiTH6oDlYFrjrw==",
+      "hasInstallScript": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@puppeteer/browsers": "2.10.8",
+        "chromium-bidi": "8.0.0",
+        "cosmiconfig": "^9.0.0",
+        "devtools-protocol": "0.0.1475386",
+        "puppeteer-core": "24.18.0",
+        "typed-query-selector": "^2.12.0"
+      },
+      "bin": {
+        "puppeteer": "lib/cjs/puppeteer/node/cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/puppeteer-core": {
+      "version": "24.18.0",
+      "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-24.18.0.tgz",
+      "integrity": "sha512-As0BvfXxek2MbV0m7iqBmQKFnfSrzSvTM4zGipjd4cL+9f2Ccgut6RvHlc8+qBieKHqCMFy9BSI4QyveoYXTug==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@puppeteer/browsers": "2.10.8",
+        "chromium-bidi": "8.0.0",
+        "debug": "^4.4.1",
+        "devtools-protocol": "0.0.1475386",
+        "typed-query-selector": "^2.12.0",
+        "ws": "^8.18.3"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/puppeteer-core/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/puppeteer-core/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/qs": {
+      "version": "6.13.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
+      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
+      "dependencies": {
+        "side-channel": "^1.0.6"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/random-bytes": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/random-bytes/-/random-bytes-1.0.0.tgz",
+      "integrity": "sha512-iv7LhNVO047HzYR3InF6pUcUsPQiHTM1Qal51DcGSuZFBil1aBBWG5eHPNek7bvILMaYJ/8RU1e8w1AMdHmLQQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz",
+      "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/readable-stream": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "license": "MIT",
+      "dependencies": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/rimraf": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+      "deprecated": "Rimraf versions prior to v4 are no longer supported",
+      "license": "ISC",
+      "dependencies": {
+        "glob": "^7.1.3"
+      },
+      "bin": {
+        "rimraf": "bin.js"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/router": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
+      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.0",
+        "depd": "^2.0.0",
+        "is-promise": "^4.0.0",
+        "parseurl": "^1.3.3",
+        "path-to-regexp": "^8.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/router/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/router/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/router/node_modules/path-to-regexp": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.2.0.tgz",
+      "integrity": "sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
+    },
+    "node_modules/semver": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/send": {
+      "version": "0.19.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz",
+      "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/send/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+    },
+    "node_modules/serve-static": {
+      "version": "1.16.2",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz",
+      "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==",
+      "dependencies": {
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "0.19.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==",
+      "license": "ISC"
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+      "license": "ISC"
+    },
+    "node_modules/simple-update-notifier": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
+      "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",
+      "dev": true,
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/smart-buffer": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+      "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/socket.io": {
+      "version": "4.8.1",
+      "resolved": "https://registry.npmjs.org/socket.io/-/socket.io-4.8.1.tgz",
+      "integrity": "sha512-oZ7iUCxph8WYRHHcjBEc9unw3adt5CmSNlppj/5Q4k2RIrhl8Z5yY2Xr4j9zj0+wzVZ0bxmYoGSzKJnRl6A4yg==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.4",
+        "base64id": "~2.0.0",
+        "cors": "~2.8.5",
+        "debug": "~4.3.2",
+        "engine.io": "~6.6.0",
+        "socket.io-adapter": "~2.5.2",
+        "socket.io-parser": "~4.2.4"
+      },
+      "engines": {
+        "node": ">=10.2.0"
+      }
+    },
+    "node_modules/socket.io-adapter": {
+      "version": "2.5.5",
+      "resolved": "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-2.5.5.tgz",
+      "integrity": "sha512-eLDQas5dzPgOWCk9GuuJC2lBqItuhKI4uxGgo9aIV7MYbk2h9Q6uULEh8WBzThoI7l+qU9Ast9fVUmkqPP9wYg==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "~4.3.4",
+        "ws": "~8.17.1"
+      }
+    },
+    "node_modules/socket.io-adapter/node_modules/debug": {
+      "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/socket.io-adapter/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/socket.io-adapter/node_modules/ws": {
+      "version": "8.17.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz",
+      "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/socket.io-parser": {
+      "version": "4.2.4",
+      "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-4.2.4.tgz",
+      "integrity": "sha512-/GbIKmo8ioc+NIWIhwdecY0ge+qVBSMdgxGygevmdHj24bsfgtCmcUUcQ5ZzcylGFHsN3k4HB4Cgkl96KVnuew==",
+      "license": "MIT",
+      "dependencies": {
+        "@socket.io/component-emitter": "~3.1.0",
+        "debug": "~4.3.1"
+      },
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/socket.io-parser/node_modules/debug": {
+      "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/socket.io-parser/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/socket.io/node_modules/debug": {
+      "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/socket.io/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/socks": {
+      "version": "2.8.7",
+      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.7.tgz",
+      "integrity": "sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==",
+      "license": "MIT",
+      "dependencies": {
+        "ip-address": "^10.0.1",
+        "smart-buffer": "^4.2.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/socks-proxy-agent": {
+      "version": "8.0.5",
+      "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
+      "integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "socks": "^2.8.3"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/socks-proxy-agent/node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/socks-proxy-agent/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/socks-proxy-agent/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "license": "BSD-3-Clause",
+      "optional": true,
+      "engines": {
+        "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==",
+      "engines": {
+        "node": ">= 10.x"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/streamx": {
+      "version": "2.22.1",
+      "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.22.1.tgz",
+      "integrity": "sha512-znKXEBxfatz2GBNK02kRnCXjV+AA4kjZIUxeWSr3UGirZMJfTE9uiwKHobnbgxWyL/JWro8tTq+vOqAK1/qbSA==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-fifo": "^1.3.2",
+        "text-decoder": "^1.1.0"
+      },
+      "optionalDependencies": {
+        "bare-events": "^2.2.0"
+      }
+    },
+    "node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
+      "dependencies": {
+        "has-flag": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/swagger-jsdoc": {
+      "version": "6.2.8",
+      "resolved": "https://registry.npmjs.org/swagger-jsdoc/-/swagger-jsdoc-6.2.8.tgz",
+      "integrity": "sha512-VPvil1+JRpmJ55CgAtn8DIcpBs0bL5L3q5bVQvF4tAW/k/9JYSj7dCpaYCAv5rufe0vcCbBRQXGvzpkWjvLklQ==",
+      "license": "MIT",
+      "dependencies": {
+        "commander": "6.2.0",
+        "doctrine": "3.0.0",
+        "glob": "7.1.6",
+        "lodash.mergewith": "^4.6.2",
+        "swagger-parser": "^10.0.3",
+        "yaml": "2.0.0-1"
+      },
+      "bin": {
+        "swagger-jsdoc": "bin/swagger-jsdoc.js"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/swagger-jsdoc/node_modules/glob": {
+      "version": "7.1.6",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+      "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.0.4",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/swagger-parser": {
+      "version": "10.0.3",
+      "resolved": "https://registry.npmjs.org/swagger-parser/-/swagger-parser-10.0.3.tgz",
+      "integrity": "sha512-nF7oMeL4KypldrQhac8RyHerJeGPD1p2xDh900GPvc+Nk7nWP6jX2FcC7WmkinMoAmoO774+AFXcWsW8gMWEIg==",
+      "license": "MIT",
+      "dependencies": {
+        "@apidevtools/swagger-parser": "10.0.3"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/swagger-ui-dist": {
+      "version": "5.28.1",
+      "resolved": "https://registry.npmjs.org/swagger-ui-dist/-/swagger-ui-dist-5.28.1.tgz",
+      "integrity": "sha512-IvPrtNi8MvjiuDgoSmPYgg27Lvu38fnLD1OSd8Y103xXsPAqezVNnNeHnVCZ/d+CMXJblflGaIyHxAYIF3O71w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@scarf/scarf": "=1.4.0"
+      }
+    },
+    "node_modules/swagger-ui-express": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/swagger-ui-express/-/swagger-ui-express-5.0.1.tgz",
+      "integrity": "sha512-SrNU3RiBGTLLmFU8GIJdOdanJTl4TOmT27tt3bWWHppqYmAZ6IDuEuBvMU6nZq0zLEe6b/1rACXCgLZqO6ZfrA==",
+      "license": "MIT",
+      "dependencies": {
+        "swagger-ui-dist": ">=5.0.0"
+      },
+      "engines": {
+        "node": ">= v0.10.32"
+      },
+      "peerDependencies": {
+        "express": ">=4.0.0 || >=5.0.0-beta"
+      }
+    },
+    "node_modules/tar": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz",
+      "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==",
+      "license": "ISC",
+      "dependencies": {
+        "chownr": "^2.0.0",
+        "fs-minipass": "^2.0.0",
+        "minipass": "^5.0.0",
+        "minizlib": "^2.1.1",
+        "mkdirp": "^1.0.3",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/tar-fs": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.0.tgz",
+      "integrity": "sha512-5Mty5y/sOF1YWj1J6GiBodjlDc05CUR8PKXrsnFAiSG0xA+GHeWLovaZPYUDXkH/1iKRf2+M5+OrRgzC7O9b7w==",
+      "license": "MIT",
+      "dependencies": {
+        "pump": "^3.0.0",
+        "tar-stream": "^3.1.5"
+      },
+      "optionalDependencies": {
+        "bare-fs": "^4.0.1",
+        "bare-path": "^3.0.0"
+      }
+    },
+    "node_modules/tar-stream": {
+      "version": "3.1.7",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.7.tgz",
+      "integrity": "sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==",
+      "license": "MIT",
+      "dependencies": {
+        "b4a": "^1.6.4",
+        "fast-fifo": "^1.2.0",
+        "streamx": "^2.15.0"
+      }
+    },
+    "node_modules/text-decoder": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.3.tgz",
+      "integrity": "sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "b4a": "^1.6.4"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/touch": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.1.tgz",
+      "integrity": "sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==",
+      "dev": true,
+      "bin": {
+        "nodetouch": "bin/nodetouch.js"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
+      "license": "MIT"
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/typed-query-selector": {
+      "version": "2.12.0",
+      "resolved": "https://registry.npmjs.org/typed-query-selector/-/typed-query-selector-2.12.0.tgz",
+      "integrity": "sha512-SbklCd1F0EiZOyPiW192rrHZzZ5sBijB6xM+cpmrwDqObvdtunOHHIk9fCGsoK5JVIYXoyEp4iEdE3upFH3PAg==",
+      "license": "MIT"
+    },
+    "node_modules/uid-safe": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/uid-safe/-/uid-safe-2.1.5.tgz",
+      "integrity": "sha512-KPHm4VL5dDXKz01UuEd88Df+KzynaohSL9fBh096KWAxSKZQDI2uBrVqtvRM4rwrIrRRKsdLNML/lnaaVSRioA==",
+      "license": "MIT",
+      "dependencies": {
+        "random-bytes": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/uid2": {
+      "version": "0.0.4",
+      "resolved": "https://registry.npmjs.org/uid2/-/uid2-0.0.4.tgz",
+      "integrity": "sha512-IevTus0SbGwQzYh3+fRsAMTVVPOoIVufzacXcHPmdlle1jUpq7BRL+mw3dgeLanvGZdwwbWhRV6XrcFNdBmjWA==",
+      "license": "MIT"
+    },
+    "node_modules/undefsafe": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.5.tgz",
+      "integrity": "sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==",
+      "dev": true
+    },
+    "node_modules/undici-types": {
+      "version": "7.10.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.10.0.tgz",
+      "integrity": "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag==",
+      "license": "MIT"
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "license": "MIT"
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/uuid": {
+      "version": "12.0.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-12.0.0.tgz",
+      "integrity": "sha512-USe1zesMYh4fjCA8ZH5+X5WIVD0J4V1Jksm1bFTVBX2F/cwSXt0RO5w/3UXbdLKmZX65MiWV+hwhSS8p6oBTGA==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "license": "MIT",
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    },
+    "node_modules/validator": {
+      "version": "13.15.15",
+      "resolved": "https://registry.npmjs.org/validator/-/validator-13.15.15.tgz",
+      "integrity": "sha512-BgWVbCI72aIQy937xbawcs+hrVaN/CZ2UwutgaJ36hGqRrLNM+f5LUT/YPRbo8IV/ASeFzXszezV+y2+rq3l8A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/web-push": {
+      "version": "3.6.7",
+      "resolved": "https://registry.npmjs.org/web-push/-/web-push-3.6.7.tgz",
+      "integrity": "sha512-OpiIUe8cuGjrj3mMBFWY+e4MMIkW3SVT+7vEIjvD9kejGUypv8GPDf84JdPWskK8zMRIJ6xYGm+Kxr8YkPyA0A==",
+      "license": "MPL-2.0",
+      "dependencies": {
+        "asn1.js": "^5.3.0",
+        "http_ece": "1.2.0",
+        "https-proxy-agent": "^7.0.0",
+        "jws": "^4.0.0",
+        "minimist": "^1.2.5"
+      },
+      "bin": {
+        "web-push": "src/cli.js"
+      },
+      "engines": {
+        "node": ">= 16"
+      }
+    },
+    "node_modules/web-push/node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/web-push/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/web-push/node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/web-push/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/wide-align": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz",
+      "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^1.0.2 || 2 || 3 || 4"
+      }
+    },
+    "node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "license": "ISC"
+    },
+    "node_modules/ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "engines": {
+        "node": ">=0.4"
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+      "license": "ISC"
+    },
+    "node_modules/yaml": {
+      "version": "2.0.0-1",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.0.0-1.tgz",
+      "integrity": "sha512-W7h5dEhywMKenDJh2iX/LABkbFnBxasD27oyXWDS/feDsxiw0dD5ncXdYXgkvAsXIY2MpW/ZKkr9IU30DBdMNQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yauzl": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
+      "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-crc32": "~0.2.3",
+        "fd-slicer": "~1.1.0"
+      }
+    },
+    "node_modules/z-schema": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/z-schema/-/z-schema-5.0.5.tgz",
+      "integrity": "sha512-D7eujBWkLa3p2sIpJA0d1pr7es+a7m0vFAnZLlCEKq/Ij2k0MLi9Br2UPxoxdYystm5K1yeBGzub0FlYUEWj2Q==",
+      "license": "MIT",
+      "dependencies": {
+        "lodash.get": "^4.4.2",
+        "lodash.isequal": "^4.5.0",
+        "validator": "^13.7.0"
+      },
+      "bin": {
+        "z-schema": "bin/z-schema"
+      },
+      "engines": {
+        "node": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "commander": "^9.4.1"
+      }
+    },
+    "node_modules/z-schema/node_modules/commander": {
+      "version": "9.5.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
+      "integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": "^12.20.0 || >=14"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.24.6",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.24.6.tgz",
+      "integrity": "sha512-h/z3PKvcTcTetyjl1fkj79MHNEjm+HpD6NXheWjzOekY7kV+lwDYnHw+ivHkijnCSMz1yJaWBD9vu/Fcmk+vEg==",
+      "license": "ISC",
+      "peerDependencies": {
+        "zod": "^3.24.1"
+      }
+    }
+  },
+  "dependencies": {
+    "@apidevtools/json-schema-ref-parser": {
+      "version": "9.1.2",
+      "resolved": "https://registry.npmjs.org/@apidevtools/json-schema-ref-parser/-/json-schema-ref-parser-9.1.2.tgz",
+      "integrity": "sha512-r1w81DpR+KyRWd3f+rk6TNqMgedmAxZP5v5KWlXQWlgMUUtyEJch0DKEci1SorPMiSeM8XPl7MZ3miJ60JIpQg==",
+      "requires": {
+        "@jsdevtools/ono": "^7.1.3",
+        "@types/json-schema": "^7.0.6",
+        "call-me-maybe": "^1.0.1",
+        "js-yaml": "^4.1.0"
+      }
+    },
+    "@apidevtools/openapi-schemas": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@apidevtools/openapi-schemas/-/openapi-schemas-2.1.0.tgz",
+      "integrity": "sha512-Zc1AlqrJlX3SlpupFGpiLi2EbteyP7fXmUOGup6/DnkRgjP9bgMM/ag+n91rsv0U1Gpz0H3VILA/o3bW7Ua6BQ=="
+    },
+    "@apidevtools/swagger-methods": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@apidevtools/swagger-methods/-/swagger-methods-3.0.2.tgz",
+      "integrity": "sha512-QAkD5kK2b1WfjDS/UQn/qQkbwF31uqRjPTrsCs5ZG9BQGAkjwvqGFjjPqAuzac/IYzpPtRzjCP1WrTuAIjMrXg=="
+    },
+    "@apidevtools/swagger-parser": {
+      "version": "10.0.3",
+      "resolved": "https://registry.npmjs.org/@apidevtools/swagger-parser/-/swagger-parser-10.0.3.tgz",
+      "integrity": "sha512-sNiLY51vZOmSPFZA5TF35KZ2HbgYklQnTSDnkghamzLb3EkNtcQnrBQEj5AOCxHpTtXpqMCRM1CrmV2rG6nw4g==",
+      "requires": {
+        "@apidevtools/json-schema-ref-parser": "^9.0.6",
+        "@apidevtools/openapi-schemas": "^2.0.4",
+        "@apidevtools/swagger-methods": "^3.0.2",
+        "@jsdevtools/ono": "^7.1.3",
+        "call-me-maybe": "^1.0.1",
+        "z-schema": "^5.0.1"
+      }
+    },
+    "@babel/code-frame": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+      "requires": {
+        "@babel/helper-validator-identifier": "^7.27.1",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      }
+    },
+    "@babel/helper-validator-identifier": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+      "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="
+    },
+    "@hisma/server-puppeteer": {
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/@hisma/server-puppeteer/-/server-puppeteer-0.6.5.tgz",
+      "integrity": "sha512-D8U2Va5Ay7MISKBdC4o8R/5w7VX24ZhqdoyTpxnxSOPL7IeedDeV2/18eCauvfa59g5p0aD+VwVN7JEpcWALXg==",
+      "requires": {
+        "@modelcontextprotocol/sdk": "^1.13.2",
+        "puppeteer": "^24.11.0"
+      },
+      "dependencies": {
+        "@modelcontextprotocol/sdk": {
+          "version": "1.17.4",
+          "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.17.4.tgz",
+          "integrity": "sha512-zq24hfuAmmlNZvik0FLI58uE5sriN0WWsQzIlYnzSuKDAHFqJtBFrl/LfB1NLgJT5Y7dEBzaX4yAKqOPrcetaw==",
+          "requires": {
+            "ajv": "^6.12.6",
+            "content-type": "^1.0.5",
+            "cors": "^2.8.5",
+            "cross-spawn": "^7.0.5",
+            "eventsource": "^3.0.2",
+            "eventsource-parser": "^3.0.0",
+            "express": "^5.0.1",
+            "express-rate-limit": "^7.5.0",
+            "pkce-challenge": "^5.0.0",
+            "raw-body": "^3.0.0",
+            "zod": "^3.23.8",
+            "zod-to-json-schema": "^3.24.1"
+          }
+        },
+        "accepts": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
+          "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
+          "requires": {
+            "mime-types": "^3.0.0",
+            "negotiator": "^1.0.0"
+          }
+        },
+        "body-parser": {
+          "version": "2.2.0",
+          "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.0.tgz",
+          "integrity": "sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==",
+          "requires": {
+            "bytes": "^3.1.2",
+            "content-type": "^1.0.5",
+            "debug": "^4.4.0",
+            "http-errors": "^2.0.0",
+            "iconv-lite": "^0.6.3",
+            "on-finished": "^2.4.1",
+            "qs": "^6.14.0",
+            "raw-body": "^3.0.0",
+            "type-is": "^2.0.0"
+          }
+        },
+        "content-disposition": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.0.tgz",
+          "integrity": "sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==",
+          "requires": {
+            "safe-buffer": "5.2.1"
+          }
+        },
+        "cookie-signature": {
+          "version": "1.2.2",
+          "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
+          "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg=="
+        },
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "express": {
+          "version": "5.1.0",
+          "resolved": "https://registry.npmjs.org/express/-/express-5.1.0.tgz",
+          "integrity": "sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==",
+          "requires": {
+            "accepts": "^2.0.0",
+            "body-parser": "^2.2.0",
+            "content-disposition": "^1.0.0",
+            "content-type": "^1.0.5",
+            "cookie": "^0.7.1",
+            "cookie-signature": "^1.2.1",
+            "debug": "^4.4.0",
+            "encodeurl": "^2.0.0",
+            "escape-html": "^1.0.3",
+            "etag": "^1.8.1",
+            "finalhandler": "^2.1.0",
+            "fresh": "^2.0.0",
+            "http-errors": "^2.0.0",
+            "merge-descriptors": "^2.0.0",
+            "mime-types": "^3.0.0",
+            "on-finished": "^2.4.1",
+            "once": "^1.4.0",
+            "parseurl": "^1.3.3",
+            "proxy-addr": "^2.0.7",
+            "qs": "^6.14.0",
+            "range-parser": "^1.2.1",
+            "router": "^2.2.0",
+            "send": "^1.1.0",
+            "serve-static": "^2.2.0",
+            "statuses": "^2.0.1",
+            "type-is": "^2.0.1",
+            "vary": "^1.1.2"
+          }
+        },
+        "finalhandler": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.0.tgz",
+          "integrity": "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==",
+          "requires": {
+            "debug": "^4.4.0",
+            "encodeurl": "^2.0.0",
+            "escape-html": "^1.0.3",
+            "on-finished": "^2.4.1",
+            "parseurl": "^1.3.3",
+            "statuses": "^2.0.1"
+          }
+        },
+        "fresh": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
+          "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A=="
+        },
+        "iconv-lite": {
+          "version": "0.6.3",
+          "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+          "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+          "requires": {
+            "safer-buffer": ">= 2.1.2 < 3.0.0"
+          }
+        },
+        "media-typer": {
+          "version": "1.1.0",
+          "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
+          "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw=="
+        },
+        "merge-descriptors": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
+          "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g=="
+        },
+        "mime-db": {
+          "version": "1.54.0",
+          "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
+          "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="
+        },
+        "mime-types": {
+          "version": "3.0.1",
+          "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.1.tgz",
+          "integrity": "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==",
+          "requires": {
+            "mime-db": "^1.54.0"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        },
+        "negotiator": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
+          "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg=="
+        },
+        "qs": {
+          "version": "6.14.0",
+          "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz",
+          "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==",
+          "requires": {
+            "side-channel": "^1.1.0"
+          }
+        },
+        "raw-body": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.0.tgz",
+          "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==",
+          "requires": {
+            "bytes": "3.1.2",
+            "http-errors": "2.0.0",
+            "iconv-lite": "0.6.3",
+            "unpipe": "1.0.0"
+          }
+        },
+        "send": {
+          "version": "1.2.0",
+          "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz",
+          "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==",
+          "requires": {
+            "debug": "^4.3.5",
+            "encodeurl": "^2.0.0",
+            "escape-html": "^1.0.3",
+            "etag": "^1.8.1",
+            "fresh": "^2.0.0",
+            "http-errors": "^2.0.0",
+            "mime-types": "^3.0.1",
+            "ms": "^2.1.3",
+            "on-finished": "^2.4.1",
+            "range-parser": "^1.2.1",
+            "statuses": "^2.0.1"
+          }
+        },
+        "serve-static": {
+          "version": "2.2.0",
+          "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.0.tgz",
+          "integrity": "sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==",
+          "requires": {
+            "encodeurl": "^2.0.0",
+            "escape-html": "^1.0.3",
+            "parseurl": "^1.3.3",
+            "send": "^1.2.0"
+          }
+        },
+        "type-is": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz",
+          "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==",
+          "requires": {
+            "content-type": "^1.0.5",
+            "media-typer": "^1.1.0",
+            "mime-types": "^3.0.0"
+          }
+        }
+      }
+    },
+    "@jsdevtools/ono": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/@jsdevtools/ono/-/ono-7.1.3.tgz",
+      "integrity": "sha512-4JQNk+3mVzK3xh2rqd6RB4J46qUR19azEHBneZyTZM+c456qOrbbM/5xcR8huNCCcbVt7+UmizG6GuUvPvKUYg=="
+    },
+    "@mapbox/node-pre-gyp": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/@mapbox/node-pre-gyp/-/node-pre-gyp-1.0.11.tgz",
+      "integrity": "sha512-Yhlar6v9WQgUp/He7BdgzOz8lqMQ8sU+jkCq7Wx8Myc5YFJLbEe7lgui/V7G1qB1DJykHSGwreceSaD60Y0PUQ==",
+      "requires": {
+        "detect-libc": "^2.0.0",
+        "https-proxy-agent": "^5.0.0",
+        "make-dir": "^3.1.0",
+        "node-fetch": "^2.6.7",
+        "nopt": "^5.0.0",
+        "npmlog": "^5.0.1",
+        "rimraf": "^3.0.2",
+        "semver": "^7.3.5",
+        "tar": "^6.1.11"
+      }
+    },
+    "@modelcontextprotocol/sdk": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.0.1.tgz",
+      "integrity": "sha512-slLdFaxQJ9AlRg+hw28iiTtGvShAOgOKXcD0F91nUcRYiOMuS9ZBYjcdNZRXW9G5JQ511GRTdUy1zQVZDpJ+4w==",
+      "requires": {
+        "content-type": "^1.0.5",
+        "raw-body": "^3.0.0",
+        "zod": "^3.23.8"
+      },
+      "dependencies": {
+        "iconv-lite": {
+          "version": "0.6.3",
+          "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+          "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+          "requires": {
+            "safer-buffer": ">= 2.1.2 < 3.0.0"
+          }
+        },
+        "raw-body": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.0.tgz",
+          "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==",
+          "requires": {
+            "bytes": "3.1.2",
+            "http-errors": "2.0.0",
+            "iconv-lite": "0.6.3",
+            "unpipe": "1.0.0"
+          }
+        }
+      }
+    },
+    "@puppeteer/browsers": {
+      "version": "2.10.8",
+      "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.10.8.tgz",
+      "integrity": "sha512-f02QYEnBDE0p8cteNoPYHHjbDuwyfbe4cCIVlNi8/MRicIxFW4w4CfgU0LNgWEID6s06P+hRJ1qjpBLMhPRCiQ==",
+      "requires": {
+        "debug": "^4.4.1",
+        "extract-zip": "^2.0.1",
+        "progress": "^2.0.3",
+        "proxy-agent": "^6.5.0",
+        "semver": "^7.7.2",
+        "tar-fs": "^3.1.0",
+        "yargs": "^17.7.2"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "@scarf/scarf": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/@scarf/scarf/-/scarf-1.4.0.tgz",
+      "integrity": "sha512-xxeapPiUXdZAE3che6f3xogoJPeZgig6omHEy1rIY5WVsB3H2BHNnZH+gHG6x91SCWyQCzWGsuL2Hh3ClO5/qQ=="
+    },
+    "@socket.io/component-emitter": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@socket.io/component-emitter/-/component-emitter-3.1.2.tgz",
+      "integrity": "sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA=="
+    },
+    "@tootallnate/quickjs-emscripten": {
+      "version": "0.23.0",
+      "resolved": "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz",
+      "integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA=="
+    },
+    "@types/cors": {
+      "version": "2.8.19",
+      "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
+      "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="
+    },
+    "@types/node": {
+      "version": "24.3.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.3.0.tgz",
+      "integrity": "sha512-aPTXCrfwnDLj4VvXrm+UUCQjNEvJgNA8s5F1cvwQU+3KNltTOkBm1j30uNLyqqPNe7gE3KFzImYoZEfLhp4Yow==",
+      "requires": {
+        "undici-types": "~7.10.0"
+      }
+    },
+    "@types/yauzl": {
+      "version": "2.10.3",
+      "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
+      "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",
+      "optional": true,
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "abbrev": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
+      "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q=="
+    },
+    "accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "requires": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      }
+    },
+    "agent-base": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
+      "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+      "requires": {
+        "debug": "4"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "requires": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      }
+    },
+    "ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="
+    },
+    "ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "requires": {
+        "color-convert": "^2.0.1"
+      }
+    },
+    "anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "requires": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      }
+    },
+    "aproba": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.1.0.tgz",
+      "integrity": "sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew=="
+    },
+    "are-we-there-yet": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-2.0.0.tgz",
+      "integrity": "sha512-Ci/qENmwHnsYo9xKIcUJN5LeDKdJ6R1Z1j9V/J5wyq8nh/mYPEpIKJbBZXtZjG04HiK7zV/p6Vs9952MrMeUIw==",
+      "requires": {
+        "delegates": "^1.0.0",
+        "readable-stream": "^3.6.0"
+      }
+    },
+    "argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="
+    },
+    "array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg=="
+    },
+    "asn1.js": {
+      "version": "5.4.1",
+      "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-5.4.1.tgz",
+      "integrity": "sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==",
+      "requires": {
+        "bn.js": "^4.0.0",
+        "inherits": "^2.0.1",
+        "minimalistic-assert": "^1.0.0",
+        "safer-buffer": "^2.1.0"
+      }
+    },
+    "ast-types": {
+      "version": "0.13.4",
+      "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.13.4.tgz",
+      "integrity": "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==",
+      "requires": {
+        "tslib": "^2.0.1"
+      }
+    },
+    "b4a": {
+      "version": "1.6.7",
+      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.7.tgz",
+      "integrity": "sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg=="
+    },
+    "balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
+    },
+    "bare-events": {
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.6.1.tgz",
+      "integrity": "sha512-AuTJkq9XmE6Vk0FJVNq5QxETrSA/vKHarWVBG5l/JbdCL1prJemiyJqUS0jrlXO0MftuPq4m3YVYhoNc5+aE/g==",
+      "optional": true
+    },
+    "bare-fs": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.2.2.tgz",
+      "integrity": "sha512-5vn+bdnlCYMwETIm1FqQXDP6TYPbxr2uJd88ve40kr4oPbiTZJVrTNzqA3/4sfWZeWKuQR/RkboBt7qEEDtfMA==",
+      "optional": true,
+      "requires": {
+        "bare-events": "^2.5.4",
+        "bare-path": "^3.0.0",
+        "bare-stream": "^2.6.4"
+      }
+    },
+    "bare-os": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.2.tgz",
+      "integrity": "sha512-T+V1+1srU2qYNBmJCXZkUY5vQ0B4FSlL3QDROnKQYOqeiQR8UbjNHlPa+TIbM4cuidiN9GaTaOZgSEgsvPbh5A==",
+      "optional": true
+    },
+    "bare-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.0.tgz",
+      "integrity": "sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==",
+      "optional": true,
+      "requires": {
+        "bare-os": "^3.0.1"
+      }
+    },
+    "bare-stream": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.7.0.tgz",
+      "integrity": "sha512-oyXQNicV1y8nc2aKffH+BUHFRXmx6VrPzlnaEvMhram0nPBrKcEdcyBg5r08D0i8VxngHFAiVyn1QKXpSG0B8A==",
+      "optional": true,
+      "requires": {
+        "streamx": "^2.21.0"
+      }
+    },
+    "base64id": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/base64id/-/base64id-2.0.0.tgz",
+      "integrity": "sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog=="
+    },
+    "base64url": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/base64url/-/base64url-3.0.1.tgz",
+      "integrity": "sha512-ir1UPr3dkwexU7FdV8qBBbNDRUhMmIekYMFZfi+C/sLNnRESKPl23nB9b2pltqfOQNnGzsDdId90AEtG5tCx4A=="
+    },
+    "basic-ftp": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.0.5.tgz",
+      "integrity": "sha512-4Bcg1P8xhUuqcii/S0Z9wiHIrQVPMermM1any+MX5GeGD7faD3/msQUDGLol9wOcz4/jbg/WJnGqoJF6LiBdtg=="
+    },
+    "bcrypt": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/bcrypt/-/bcrypt-5.1.1.tgz",
+      "integrity": "sha512-AGBHOG5hPYZ5Xl9KXzU5iKq9516yEmvCKDg3ecP5kX2aB6UqTeXZxk2ELnDgDm6BQSMlLt9rDB4LoSMx0rYwww==",
+      "requires": {
+        "@mapbox/node-pre-gyp": "^1.0.11",
+        "node-addon-api": "^5.0.0"
+      }
+    },
+    "binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true
+    },
+    "bn.js": {
+      "version": "4.12.2",
+      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.2.tgz",
+      "integrity": "sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw=="
+    },
+    "body-parser": {
+      "version": "1.20.3",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
+      "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
+      "requires": {
+        "bytes": "3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "on-finished": "2.4.1",
+        "qs": "6.13.0",
+        "raw-body": "2.5.2",
+        "type-is": "~1.6.18",
+        "unpipe": "1.0.0"
+      }
+    },
+    "brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "requires": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "requires": {
+        "fill-range": "^7.1.1"
+      }
+    },
+    "buffer-crc32": {
+      "version": "0.2.13",
+      "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+      "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ=="
+    },
+    "buffer-equal-constant-time": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
+      "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA=="
+    },
+    "bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="
+    },
+    "call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "requires": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      }
+    },
+    "call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "requires": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      }
+    },
+    "call-me-maybe": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-me-maybe/-/call-me-maybe-1.0.2.tgz",
+      "integrity": "sha512-HpX65o1Hnr9HH25ojC1YGs7HCQLq0GCOibSaWER0eNpgJ/Z1MZv2mTc7+xh6WOPxbRVcmgbv4hGU+uSQ/2xFZQ=="
+    },
+    "callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="
+    },
+    "chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "requires": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "fsevents": "~2.3.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      }
+    },
+    "chownr": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz",
+      "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ=="
+    },
+    "chromium-bidi": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-8.0.0.tgz",
+      "integrity": "sha512-d1VmE0FD7lxZQHzcDUCKZSNRtRwISXDsdg4HjdTR5+Ll5nQ/vzU12JeNmupD6VWffrPSlrnGhEWlLESKH3VO+g==",
+      "requires": {
+        "mitt": "^3.0.1",
+        "zod": "^3.24.1"
+      }
+    },
+    "cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "requires": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      }
+    },
+    "color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "requires": {
+        "color-name": "~1.1.4"
+      }
+    },
+    "color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
+    },
+    "color-support": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz",
+      "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg=="
+    },
+    "commander": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-6.2.0.tgz",
+      "integrity": "sha512-zP4jEKbe8SHzKJYQmq8Y9gYjtO/POJLgIdKgV7B9qNmABVFVc+ctqSX6iXh4mCpJfRBOabiZ2YKPg8ciDw6C+Q=="
+    },
+    "concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="
+    },
+    "console-control-strings": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz",
+      "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ=="
+    },
+    "content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "requires": {
+        "safe-buffer": "5.2.1"
+      }
+    },
+    "content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA=="
+    },
+    "cookie": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
+      "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w=="
+    },
+    "cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ=="
+    },
+    "cors": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
+      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "requires": {
+        "object-assign": "^4",
+        "vary": "^1"
+      }
+    },
+    "cosmiconfig": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-9.0.0.tgz",
+      "integrity": "sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==",
+      "requires": {
+        "env-paths": "^2.2.1",
+        "import-fresh": "^3.3.0",
+        "js-yaml": "^4.1.0",
+        "parse-json": "^5.2.0"
+      }
+    },
+    "cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "requires": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      }
+    },
+    "data-uri-to-buffer": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz",
+      "integrity": "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw=="
+    },
+    "debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "requires": {
+        "ms": "2.0.0"
+      }
+    },
+    "degenerator": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/degenerator/-/degenerator-5.0.1.tgz",
+      "integrity": "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==",
+      "requires": {
+        "ast-types": "^0.13.4",
+        "escodegen": "^2.1.0",
+        "esprima": "^4.0.1"
+      }
+    },
+    "delegates": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz",
+      "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ=="
+    },
+    "depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="
+    },
+    "destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg=="
+    },
+    "detect-libc": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.4.tgz",
+      "integrity": "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA=="
+    },
+    "devtools-protocol": {
+      "version": "0.0.1475386",
+      "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1475386.tgz",
+      "integrity": "sha512-RQ809ykTfJ+dgj9bftdeL2vRVxASAuGU+I9LEx9Ij5TXU5HrgAQVmzi72VA+mkzscE12uzlRv5/tWWv9R9J1SA=="
+    },
+    "discord-oauth2": {
+      "version": "2.12.1",
+      "resolved": "https://registry.npmjs.org/discord-oauth2/-/discord-oauth2-2.12.1.tgz",
+      "integrity": "sha512-/Um39bRxVjcGHUu1YaTLangZvZveXjsX4BNsa1Iyd6OQG0jL972IBQGKD0mYqQswxC3bT+hqWSouabfI2RdaZA=="
+    },
+    "doctrine": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
+      "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
+      "requires": {
+        "esutils": "^2.0.2"
+      }
+    },
+    "dotenv": {
+      "version": "16.5.0",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.5.0.tgz",
+      "integrity": "sha512-m/C+AwOAr9/W1UOIZUo232ejMNnJAJtYQjUbHoNTBNTJSvqzzDh7vnrei3o3r3m9blf6ZoDkvcw0VmozNRFJxg=="
+    },
+    "dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "requires": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      }
+    },
+    "ecdsa-sig-formatter": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
+      "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
+      "requires": {
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="
+    },
+    "emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
+    },
+    "encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="
+    },
+    "end-of-stream": {
+      "version": "1.4.5",
+      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+      "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+      "requires": {
+        "once": "^1.4.0"
+      }
+    },
+    "engine.io": {
+      "version": "6.6.4",
+      "resolved": "https://registry.npmjs.org/engine.io/-/engine.io-6.6.4.tgz",
+      "integrity": "sha512-ZCkIjSYNDyGn0R6ewHDtXgns/Zre/NT6Agvq1/WobF7JXgFff4SeDroKiCO3fNJreU9YG429Sc81o4w5ok/W5g==",
+      "requires": {
+        "@types/cors": "^2.8.12",
+        "@types/node": ">=10.0.0",
+        "accepts": "~1.3.4",
+        "base64id": "2.0.0",
+        "cookie": "~0.7.2",
+        "cors": "~2.8.5",
+        "debug": "~4.3.1",
+        "engine.io-parser": "~5.2.1",
+        "ws": "~8.17.1"
+      },
+      "dependencies": {
+        "cookie": {
+          "version": "0.7.2",
+          "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+          "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="
+        },
+        "debug": {
+          "version": "4.3.7",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+          "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        },
+        "ws": {
+          "version": "8.17.1",
+          "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz",
+          "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==",
+          "requires": {}
+        }
+      }
+    },
+    "engine.io-parser": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/engine.io-parser/-/engine.io-parser-5.2.3.tgz",
+      "integrity": "sha512-HqD3yTBfnBxIrbnM1DoD6Pcq8NECnh8d4As1Qgh0z5Gg3jRRIqijury0CL3ghu/edArpUYiYqQiDUQBIs4np3Q=="
+    },
+    "enhanced-postgres-mcp-server": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/enhanced-postgres-mcp-server/-/enhanced-postgres-mcp-server-1.0.1.tgz",
+      "integrity": "sha512-tw7GJbrgdwrNl0ZEYuytNfEwNBNqplpGCwMN3mJ3okqEl9xm3c1Dft/5N38YwUxmkAQbK86eiA6Fq95dR/2f9A==",
+      "requires": {
+        "@modelcontextprotocol/sdk": "1.0.1",
+        "pg": "^8.13.0"
+      }
+    },
+    "env-paths": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
+      "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A=="
+    },
+    "error-ex": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
+      "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
+      "requires": {
+        "is-arrayish": "^0.2.1"
+      }
+    },
+    "es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="
+    },
+    "es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="
+    },
+    "es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "requires": {
+        "es-errors": "^1.3.0"
+      }
+    },
+    "escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="
+    },
+    "escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="
+    },
+    "escodegen": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz",
+      "integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==",
+      "requires": {
+        "esprima": "^4.0.1",
+        "estraverse": "^5.2.0",
+        "esutils": "^2.0.2",
+        "source-map": "~0.6.1"
+      }
+    },
+    "esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A=="
+    },
+    "estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="
+    },
+    "esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="
+    },
+    "etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="
+    },
+    "eventsource": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz",
+      "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==",
+      "requires": {
+        "eventsource-parser": "^3.0.1"
+      }
+    },
+    "eventsource-parser": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.6.tgz",
+      "integrity": "sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg=="
+    },
+    "express": {
+      "version": "4.21.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
+      "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==",
+      "requires": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "1.20.3",
+        "content-disposition": "0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "0.7.1",
+        "cookie-signature": "1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "1.3.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "merge-descriptors": "1.0.3",
+        "methods": "~1.1.2",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "0.1.12",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.13.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "0.19.0",
+        "serve-static": "1.16.2",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      }
+    },
+    "express-rate-limit": {
+      "version": "7.5.1",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.1.tgz",
+      "integrity": "sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw==",
+      "requires": {}
+    },
+    "express-session": {
+      "version": "1.18.2",
+      "resolved": "https://registry.npmjs.org/express-session/-/express-session-1.18.2.tgz",
+      "integrity": "sha512-SZjssGQC7TzTs9rpPDuUrR23GNZ9+2+IkA/+IJWmvQilTr5OSliEHGF+D9scbIpdC6yGtTI0/VhaHoVes2AN/A==",
+      "requires": {
+        "cookie": "0.7.2",
+        "cookie-signature": "1.0.7",
+        "debug": "2.6.9",
+        "depd": "~2.0.0",
+        "on-headers": "~1.1.0",
+        "parseurl": "~1.3.3",
+        "safe-buffer": "5.2.1",
+        "uid-safe": "~2.1.5"
+      },
+      "dependencies": {
+        "cookie": {
+          "version": "0.7.2",
+          "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+          "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="
+        },
+        "cookie-signature": {
+          "version": "1.0.7",
+          "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.7.tgz",
+          "integrity": "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA=="
+        }
+      }
+    },
+    "extract-zip": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
+      "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==",
+      "requires": {
+        "@types/yauzl": "^2.9.1",
+        "debug": "^4.1.1",
+        "get-stream": "^5.1.0",
+        "yauzl": "^2.10.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="
+    },
+    "fast-fifo": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
+      "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ=="
+    },
+    "fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="
+    },
+    "fd-slicer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
+      "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
+      "requires": {
+        "pend": "~1.2.0"
+      }
+    },
+    "fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "requires": {
+        "to-regex-range": "^5.0.1"
+      }
+    },
+    "finalhandler": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz",
+      "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==",
+      "requires": {
+        "debug": "2.6.9",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "2.0.1",
+        "unpipe": "~1.0.0"
+      }
+    },
+    "forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="
+    },
+    "fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q=="
+    },
+    "fs-minipass": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",
+      "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",
+      "requires": {
+        "minipass": "^3.0.0"
+      },
+      "dependencies": {
+        "minipass": {
+          "version": "3.3.6",
+          "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+          "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+          "requires": {
+            "yallist": "^4.0.0"
+          }
+        }
+      }
+    },
+    "fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="
+    },
+    "fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "optional": true
+    },
+    "function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="
+    },
+    "gauge": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/gauge/-/gauge-3.0.2.tgz",
+      "integrity": "sha512-+5J6MS/5XksCuXq++uFRsnUd7Ovu1XenbeuIuNRJxYWjgQbPuFhT14lAvsWfqfAmnwluf1OwMjz39HjfLPci0Q==",
+      "requires": {
+        "aproba": "^1.0.3 || ^2.0.0",
+        "color-support": "^1.1.2",
+        "console-control-strings": "^1.0.0",
+        "has-unicode": "^2.0.1",
+        "object-assign": "^4.1.1",
+        "signal-exit": "^3.0.0",
+        "string-width": "^4.2.3",
+        "strip-ansi": "^6.0.1",
+        "wide-align": "^1.1.2"
+      }
+    },
+    "get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg=="
+    },
+    "get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "requires": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      }
+    },
+    "get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "requires": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      }
+    },
+    "get-stream": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
+      "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
+      "requires": {
+        "pump": "^3.0.0"
+      }
+    },
+    "get-uri": {
+      "version": "6.0.5",
+      "resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.5.tgz",
+      "integrity": "sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg==",
+      "requires": {
+        "basic-ftp": "^5.0.2",
+        "data-uri-to-buffer": "^6.0.2",
+        "debug": "^4.3.4"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "requires": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      }
+    },
+    "glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "requires": {
+        "is-glob": "^4.0.1"
+      }
+    },
+    "gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="
+    },
+    "has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+      "dev": true
+    },
+    "has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="
+    },
+    "has-unicode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz",
+      "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ=="
+    },
+    "hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "requires": {
+        "function-bind": "^1.1.2"
+      }
+    },
+    "http_ece": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/http_ece/-/http_ece-1.2.0.tgz",
+      "integrity": "sha512-JrF8SSLVmcvc5NducxgyOrKXe3EsyHMgBFgSaIUGmArKe+rwr0uphRkRXvwiom3I+fpIfoItveHrfudL8/rxuA=="
+    },
+    "http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "requires": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      }
+    },
+    "http-proxy-agent": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+      "requires": {
+        "agent-base": "^7.1.0",
+        "debug": "^4.3.4"
+      },
+      "dependencies": {
+        "agent-base": {
+          "version": "7.1.4",
+          "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+          "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ=="
+        },
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "https": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/https/-/https-1.0.0.tgz",
+      "integrity": "sha512-4EC57ddXrkaF0x83Oj8sM6SLQHAWXw90Skqu2M4AEWENZ3F02dFJE/GARA8igO79tcgYqGrD7ae4f5L3um2lgg=="
+    },
+    "https-proxy-agent": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
+      "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",
+      "requires": {
+        "agent-base": "6",
+        "debug": "4"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "requires": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      }
+    },
+    "ignore-by-default": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/ignore-by-default/-/ignore-by-default-1.0.1.tgz",
+      "integrity": "sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==",
+      "dev": true
+    },
+    "import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+      "requires": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      }
+    },
+    "inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "requires": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+    },
+    "ip-address": {
+      "version": "10.0.1",
+      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.0.1.tgz",
+      "integrity": "sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA=="
+    },
+    "ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="
+    },
+    "is-arrayish": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
+      "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg=="
+    },
+    "is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "requires": {
+        "binary-extensions": "^2.0.0"
+      }
+    },
+    "is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true
+    },
+    "is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="
+    },
+    "is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "requires": {
+        "is-extglob": "^2.1.1"
+      }
+    },
+    "is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true
+    },
+    "is-promise": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
+      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ=="
+    },
+    "isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="
+    },
+    "js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
+    },
+    "js-yaml": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "requires": {
+        "argparse": "^2.0.1"
+      }
+    },
+    "json-parse-even-better-errors": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="
+    },
+    "json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="
+    },
+    "jwa": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
+      "integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
+      "requires": {
+        "buffer-equal-constant-time": "^1.0.1",
+        "ecdsa-sig-formatter": "1.0.11",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "jws": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.0.tgz",
+      "integrity": "sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg==",
+      "requires": {
+        "jwa": "^2.0.0",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "lines-and-columns": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="
+    },
+    "lodash.get": {
+      "version": "4.4.2",
+      "resolved": "https://registry.npmjs.org/lodash.get/-/lodash.get-4.4.2.tgz",
+      "integrity": "sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ=="
+    },
+    "lodash.isequal": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
+      "integrity": "sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ=="
+    },
+    "lodash.mergewith": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.mergewith/-/lodash.mergewith-4.6.2.tgz",
+      "integrity": "sha512-GK3g5RPZWTRSeLSpgP8Xhra+pnjBC56q9FZYe1d5RN3TJ35dbkGy3YqBSMbyCrlbi+CM9Z3Jk5yTL7RCsqboyQ=="
+    },
+    "lru-cache": {
+      "version": "7.18.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+      "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA=="
+    },
+    "make-dir": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
+      "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",
+      "requires": {
+        "semver": "^6.0.0"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "6.3.1",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+          "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="
+        }
+      }
+    },
+    "math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="
+    },
+    "media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ=="
+    },
+    "merge-descriptors": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ=="
+    },
+    "methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w=="
+    },
+    "mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg=="
+    },
+    "mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="
+    },
+    "mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "requires": {
+        "mime-db": "1.52.0"
+      }
+    },
+    "minimalistic-assert": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz",
+      "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A=="
+    },
+    "minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "requires": {
+        "brace-expansion": "^1.1.7"
+      }
+    },
+    "minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="
+    },
+    "minipass": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz",
+      "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ=="
+    },
+    "minizlib": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz",
+      "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==",
+      "requires": {
+        "minipass": "^3.0.0",
+        "yallist": "^4.0.0"
+      },
+      "dependencies": {
+        "minipass": {
+          "version": "3.3.6",
+          "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+          "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+          "requires": {
+            "yallist": "^4.0.0"
+          }
+        }
+      }
+    },
+    "mitt": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
+      "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw=="
+    },
+    "mkdirp": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
+      "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw=="
+    },
+    "ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
+    },
+    "negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg=="
+    },
+    "netmask": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/netmask/-/netmask-2.0.2.tgz",
+      "integrity": "sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg=="
+    },
+    "node-addon-api": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-5.1.0.tgz",
+      "integrity": "sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA=="
+    },
+    "node-cron": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/node-cron/-/node-cron-4.2.1.tgz",
+      "integrity": "sha512-lgimEHPE/QDgFlywTd8yTR61ptugX3Qer29efeyWw2rv259HtGBNn1vZVmp8lB9uo9wC0t/AT4iGqXxia+CJFg=="
+    },
+    "node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "requires": {
+        "whatwg-url": "^5.0.0"
+      }
+    },
+    "nodemon": {
+      "version": "3.1.10",
+      "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.10.tgz",
+      "integrity": "sha512-WDjw3pJ0/0jMFmyNDp3gvY2YizjLmmOUQo6DEBY+JgdvW/yQ9mEeSw6H5ythl5Ny2ytb7f9C2nIbjSxMNzbJXw==",
+      "dev": true,
+      "requires": {
+        "chokidar": "^3.5.2",
+        "debug": "^4",
+        "ignore-by-default": "^1.0.1",
+        "minimatch": "^3.1.2",
+        "pstree.remy": "^1.1.8",
+        "semver": "^7.5.3",
+        "simple-update-notifier": "^2.0.0",
+        "supports-color": "^5.5.0",
+        "touch": "^3.1.0",
+        "undefsafe": "^2.0.5"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "dev": true,
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+          "dev": true
+        }
+      }
+    },
+    "nopt": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz",
+      "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==",
+      "requires": {
+        "abbrev": "1"
+      }
+    },
+    "normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true
+    },
+    "npmlog": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-5.0.1.tgz",
+      "integrity": "sha512-AqZtDUWOMKs1G/8lwylVjrdYgqA4d9nu8hc+0gzRxlDb1I10+FHBGMXs6aiQHFdCUUlqH99MUMuLfzWDNDtfxw==",
+      "requires": {
+        "are-we-there-yet": "^2.0.0",
+        "console-control-strings": "^1.1.0",
+        "gauge": "^3.0.0",
+        "set-blocking": "^2.0.0"
+      }
+    },
+    "oauth": {
+      "version": "0.10.2",
+      "resolved": "https://registry.npmjs.org/oauth/-/oauth-0.10.2.tgz",
+      "integrity": "sha512-JtFnB+8nxDEXgNyniwz573xxbKSOu3R8D40xQKqcjwJ2CDkYqUDI53o6IuzDJBx60Z8VKCm271+t8iFjakrl8Q=="
+    },
+    "object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg=="
+    },
+    "object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="
+    },
+    "on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "requires": {
+        "ee-first": "1.1.1"
+      }
+    },
+    "on-headers": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.1.0.tgz",
+      "integrity": "sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A=="
+    },
+    "once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "requires": {
+        "wrappy": "1"
+      }
+    },
+    "openapi-types": {
+      "version": "12.1.3",
+      "resolved": "https://registry.npmjs.org/openapi-types/-/openapi-types-12.1.3.tgz",
+      "integrity": "sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw==",
+      "peer": true
+    },
+    "pac-proxy-agent": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.2.0.tgz",
+      "integrity": "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==",
+      "requires": {
+        "@tootallnate/quickjs-emscripten": "^0.23.0",
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "get-uri": "^6.0.1",
+        "http-proxy-agent": "^7.0.0",
+        "https-proxy-agent": "^7.0.6",
+        "pac-resolver": "^7.0.1",
+        "socks-proxy-agent": "^8.0.5"
+      },
+      "dependencies": {
+        "agent-base": {
+          "version": "7.1.4",
+          "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+          "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ=="
+        },
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "https-proxy-agent": {
+          "version": "7.0.6",
+          "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+          "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+          "requires": {
+            "agent-base": "^7.1.2",
+            "debug": "4"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "pac-resolver": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/pac-resolver/-/pac-resolver-7.0.1.tgz",
+      "integrity": "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==",
+      "requires": {
+        "degenerator": "^5.0.0",
+        "netmask": "^2.0.2"
+      }
+    },
+    "parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "requires": {
+        "callsites": "^3.0.0"
+      }
+    },
+    "parse-json": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
+      "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
+      "requires": {
+        "@babel/code-frame": "^7.0.0",
+        "error-ex": "^1.3.1",
+        "json-parse-even-better-errors": "^2.3.0",
+        "lines-and-columns": "^1.1.6"
+      }
+    },
+    "parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="
+    },
+    "passport": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/passport/-/passport-0.7.0.tgz",
+      "integrity": "sha512-cPLl+qZpSc+ireUvt+IzqbED1cHHkDoVYMo30jbJIdOOjQ1MQYZBPiNvmi8UM6lJuOpTPXJGZQk0DtC4y61MYQ==",
+      "requires": {
+        "passport-strategy": "1.x.x",
+        "pause": "0.0.1",
+        "utils-merge": "^1.0.1"
+      }
+    },
+    "passport-discord": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/passport-discord/-/passport-discord-0.1.4.tgz",
+      "integrity": "sha512-VJWPYqSOmh7SaCLw/C+k1ZqCzJnn2frrmQRx1YrcPJ3MQ+Oa31XclbbmqFICSvl8xv3Fqd6YWQ4H4p1MpIN9rA==",
+      "requires": {
+        "passport-oauth2": "^1.5.0"
+      }
+    },
+    "passport-oauth2": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/passport-oauth2/-/passport-oauth2-1.8.0.tgz",
+      "integrity": "sha512-cjsQbOrXIDE4P8nNb3FQRCCmJJ/utnFKEz2NX209f7KOHPoX18gF7gBzBbLLsj2/je4KrgiwLLGjf0lm9rtTBA==",
+      "requires": {
+        "base64url": "3.x.x",
+        "oauth": "0.10.x",
+        "passport-strategy": "1.x.x",
+        "uid2": "0.0.x",
+        "utils-merge": "1.x.x"
+      }
+    },
+    "passport-strategy": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/passport-strategy/-/passport-strategy-1.0.0.tgz",
+      "integrity": "sha512-CB97UUvDKJde2V0KDWWB3lyf6PC3FaZP7YxZ2G8OAtn9p4HI9j9JLP9qjOGZFvyl8uwNT8qM+hGnz/n16NI7oA=="
+    },
+    "path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg=="
+    },
+    "path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="
+    },
+    "path-to-regexp": {
+      "version": "0.1.12",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
+      "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ=="
+    },
+    "pause": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/pause/-/pause-0.0.1.tgz",
+      "integrity": "sha512-KG8UEiEVkR3wGEb4m5yZkVCzigAD+cVEJck2CzYZO37ZGJfctvVptVO192MwrtPhzONn6go8ylnOdMhKqi4nfg=="
+    },
+    "pend": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
+      "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg=="
+    },
+    "pg": {
+      "version": "8.16.0",
+      "resolved": "https://registry.npmjs.org/pg/-/pg-8.16.0.tgz",
+      "integrity": "sha512-7SKfdvP8CTNXjMUzfcVTaI+TDzBEeaUnVwiVGZQD1Hh33Kpev7liQba9uLd4CfN8r9mCVsD0JIpq03+Unpz+kg==",
+      "requires": {
+        "pg-cloudflare": "^1.2.5",
+        "pg-connection-string": "^2.9.0",
+        "pg-pool": "^3.10.0",
+        "pg-protocol": "^1.10.0",
+        "pg-types": "2.2.0",
+        "pgpass": "1.0.5"
+      }
+    },
+    "pg-cloudflare": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.2.5.tgz",
+      "integrity": "sha512-OOX22Vt0vOSRrdoUPKJ8Wi2OpE/o/h9T8X1s4qSkCedbNah9ei2W2765be8iMVxQUsvgT7zIAT2eIa9fs5+vtg==",
+      "optional": true
+    },
+    "pg-connection-string": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.9.0.tgz",
+      "integrity": "sha512-P2DEBKuvh5RClafLngkAuGe9OUlFV7ebu8w1kmaaOgPcpJd1RIFh7otETfI6hAR8YupOLFTY7nuvvIn7PLciUQ=="
+    },
+    "pg-int8": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz",
+      "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw=="
+    },
+    "pg-pool": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.10.0.tgz",
+      "integrity": "sha512-DzZ26On4sQ0KmqnO34muPcmKbhrjmyiO4lCCR0VwEd7MjmiKf5NTg/6+apUEu0NF7ESa37CGzFxH513CoUmWnA==",
+      "requires": {}
+    },
+    "pg-protocol": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.10.0.tgz",
+      "integrity": "sha512-IpdytjudNuLv8nhlHs/UrVBhU0e78J0oIS/0AVdTbWxSOkFUVdsHC/NrorO6nXsQNDTT1kzDSOMJubBQviX18Q=="
+    },
+    "pg-types": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz",
+      "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==",
+      "requires": {
+        "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"
+      }
+    },
+    "pgpass": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz",
+      "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==",
+      "requires": {
+        "split2": "^4.1.0"
+      }
+    },
+    "picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="
+    },
+    "picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true
+    },
+    "pkce-challenge": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.0.tgz",
+      "integrity": "sha512-ueGLflrrnvwB3xuo/uGob5pd5FN7l0MsLf0Z87o/UQmRtwjvfylfc9MurIxRAWywCYTgrvpXBcqjV4OfCYGCIQ=="
+    },
+    "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=="
+    },
+    "postgres-bytea": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.0.tgz",
+      "integrity": "sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w=="
+    },
+    "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=="
+    },
+    "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==",
+      "requires": {
+        "xtend": "^4.0.0"
+      }
+    },
+    "progress": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
+      "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA=="
+    },
+    "proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "requires": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      }
+    },
+    "proxy-agent": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.5.0.tgz",
+      "integrity": "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==",
+      "requires": {
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "http-proxy-agent": "^7.0.1",
+        "https-proxy-agent": "^7.0.6",
+        "lru-cache": "^7.14.1",
+        "pac-proxy-agent": "^7.1.0",
+        "proxy-from-env": "^1.1.0",
+        "socks-proxy-agent": "^8.0.5"
+      },
+      "dependencies": {
+        "agent-base": {
+          "version": "7.1.4",
+          "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+          "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ=="
+        },
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "https-proxy-agent": {
+          "version": "7.0.6",
+          "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+          "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+          "requires": {
+            "agent-base": "^7.1.2",
+            "debug": "4"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="
+    },
+    "pstree.remy": {
+      "version": "1.1.8",
+      "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz",
+      "integrity": "sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==",
+      "dev": true
+    },
+    "pump": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
+      "integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==",
+      "requires": {
+        "end-of-stream": "^1.1.0",
+        "once": "^1.3.1"
+      }
+    },
+    "punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="
+    },
+    "puppeteer": {
+      "version": "24.18.0",
+      "resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-24.18.0.tgz",
+      "integrity": "sha512-Ke8oL/87GhzKIM2Ag6Yj49t5xbGc4rspGIuSuFLFCQBtYzWqCSanvqoCu08WkI78rbqcwnHjxiTH6oDlYFrjrw==",
+      "requires": {
+        "@puppeteer/browsers": "2.10.8",
+        "chromium-bidi": "8.0.0",
+        "cosmiconfig": "^9.0.0",
+        "devtools-protocol": "0.0.1475386",
+        "puppeteer-core": "24.18.0",
+        "typed-query-selector": "^2.12.0"
+      }
+    },
+    "puppeteer-core": {
+      "version": "24.18.0",
+      "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-24.18.0.tgz",
+      "integrity": "sha512-As0BvfXxek2MbV0m7iqBmQKFnfSrzSvTM4zGipjd4cL+9f2Ccgut6RvHlc8+qBieKHqCMFy9BSI4QyveoYXTug==",
+      "requires": {
+        "@puppeteer/browsers": "2.10.8",
+        "chromium-bidi": "8.0.0",
+        "debug": "^4.4.1",
+        "devtools-protocol": "0.0.1475386",
+        "typed-query-selector": "^2.12.0",
+        "ws": "^8.18.3"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "qs": {
+      "version": "6.13.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
+      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
+      "requires": {
+        "side-channel": "^1.0.6"
+      }
+    },
+    "random-bytes": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/random-bytes/-/random-bytes-1.0.0.tgz",
+      "integrity": "sha512-iv7LhNVO047HzYR3InF6pUcUsPQiHTM1Qal51DcGSuZFBil1aBBWG5eHPNek7bvILMaYJ/8RU1e8w1AMdHmLQQ=="
+    },
+    "range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg=="
+    },
+    "raw-body": {
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz",
+      "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
+      "requires": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "unpipe": "1.0.0"
+      }
+    },
+    "readable-stream": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "requires": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      }
+    },
+    "readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "requires": {
+        "picomatch": "^2.2.1"
+      }
+    },
+    "require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q=="
+    },
+    "resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="
+    },
+    "rimraf": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+      "requires": {
+        "glob": "^7.1.3"
+      }
+    },
+    "router": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
+      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
+      "requires": {
+        "debug": "^4.4.0",
+        "depd": "^2.0.0",
+        "is-promise": "^4.0.0",
+        "parseurl": "^1.3.3",
+        "path-to-regexp": "^8.0.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        },
+        "path-to-regexp": {
+          "version": "8.2.0",
+          "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.2.0.tgz",
+          "integrity": "sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ=="
+        }
+      }
+    },
+    "safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="
+    },
+    "safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
+    },
+    "semver": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA=="
+    },
+    "send": {
+      "version": "0.19.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz",
+      "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
+      "requires": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "2.0.1"
+      },
+      "dependencies": {
+        "encodeurl": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+          "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w=="
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "serve-static": {
+      "version": "1.16.2",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz",
+      "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==",
+      "requires": {
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "0.19.0"
+      }
+    },
+    "set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw=="
+    },
+    "setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="
+    },
+    "shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "requires": {
+        "shebang-regex": "^3.0.0"
+      }
+    },
+    "shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="
+    },
+    "side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "requires": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      }
+    },
+    "side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "requires": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      }
+    },
+    "side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "requires": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      }
+    },
+    "side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "requires": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      }
+    },
+    "signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="
+    },
+    "simple-update-notifier": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
+      "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",
+      "dev": true,
+      "requires": {
+        "semver": "^7.5.3"
+      }
+    },
+    "smart-buffer": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+      "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg=="
+    },
+    "socket.io": {
+      "version": "4.8.1",
+      "resolved": "https://registry.npmjs.org/socket.io/-/socket.io-4.8.1.tgz",
+      "integrity": "sha512-oZ7iUCxph8WYRHHcjBEc9unw3adt5CmSNlppj/5Q4k2RIrhl8Z5yY2Xr4j9zj0+wzVZ0bxmYoGSzKJnRl6A4yg==",
+      "requires": {
+        "accepts": "~1.3.4",
+        "base64id": "~2.0.0",
+        "cors": "~2.8.5",
+        "debug": "~4.3.2",
+        "engine.io": "~6.6.0",
+        "socket.io-adapter": "~2.5.2",
+        "socket.io-parser": "~4.2.4"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.3.7",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+          "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "socket.io-adapter": {
+      "version": "2.5.5",
+      "resolved": "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-2.5.5.tgz",
+      "integrity": "sha512-eLDQas5dzPgOWCk9GuuJC2lBqItuhKI4uxGgo9aIV7MYbk2h9Q6uULEh8WBzThoI7l+qU9Ast9fVUmkqPP9wYg==",
+      "requires": {
+        "debug": "~4.3.4",
+        "ws": "~8.17.1"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.3.7",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+          "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        },
+        "ws": {
+          "version": "8.17.1",
+          "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz",
+          "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==",
+          "requires": {}
+        }
+      }
+    },
+    "socket.io-parser": {
+      "version": "4.2.4",
+      "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-4.2.4.tgz",
+      "integrity": "sha512-/GbIKmo8ioc+NIWIhwdecY0ge+qVBSMdgxGygevmdHj24bsfgtCmcUUcQ5ZzcylGFHsN3k4HB4Cgkl96KVnuew==",
+      "requires": {
+        "@socket.io/component-emitter": "~3.1.0",
+        "debug": "~4.3.1"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.3.7",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+          "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "socks": {
+      "version": "2.8.7",
+      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.7.tgz",
+      "integrity": "sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==",
+      "requires": {
+        "ip-address": "^10.0.1",
+        "smart-buffer": "^4.2.0"
+      }
+    },
+    "socks-proxy-agent": {
+      "version": "8.0.5",
+      "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
+      "integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
+      "requires": {
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "socks": "^2.8.3"
+      },
+      "dependencies": {
+        "agent-base": {
+          "version": "7.1.4",
+          "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+          "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ=="
+        },
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "optional": true
+    },
+    "split2": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg=="
+    },
+    "statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ=="
+    },
+    "streamx": {
+      "version": "2.22.1",
+      "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.22.1.tgz",
+      "integrity": "sha512-znKXEBxfatz2GBNK02kRnCXjV+AA4kjZIUxeWSr3UGirZMJfTE9uiwKHobnbgxWyL/JWro8tTq+vOqAK1/qbSA==",
+      "requires": {
+        "bare-events": "^2.2.0",
+        "fast-fifo": "^1.3.2",
+        "text-decoder": "^1.1.0"
+      }
+    },
+    "string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "requires": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
+    "string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "requires": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      }
+    },
+    "strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "requires": {
+        "ansi-regex": "^5.0.1"
+      }
+    },
+    "supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
+      "requires": {
+        "has-flag": "^3.0.0"
+      }
+    },
+    "swagger-jsdoc": {
+      "version": "6.2.8",
+      "resolved": "https://registry.npmjs.org/swagger-jsdoc/-/swagger-jsdoc-6.2.8.tgz",
+      "integrity": "sha512-VPvil1+JRpmJ55CgAtn8DIcpBs0bL5L3q5bVQvF4tAW/k/9JYSj7dCpaYCAv5rufe0vcCbBRQXGvzpkWjvLklQ==",
+      "requires": {
+        "commander": "6.2.0",
+        "doctrine": "3.0.0",
+        "glob": "7.1.6",
+        "lodash.mergewith": "^4.6.2",
+        "swagger-parser": "^10.0.3",
+        "yaml": "2.0.0-1"
+      },
+      "dependencies": {
+        "glob": {
+          "version": "7.1.6",
+          "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+          "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
+          "requires": {
+            "fs.realpath": "^1.0.0",
+            "inflight": "^1.0.4",
+            "inherits": "2",
+            "minimatch": "^3.0.4",
+            "once": "^1.3.0",
+            "path-is-absolute": "^1.0.0"
+          }
+        }
+      }
+    },
+    "swagger-parser": {
+      "version": "10.0.3",
+      "resolved": "https://registry.npmjs.org/swagger-parser/-/swagger-parser-10.0.3.tgz",
+      "integrity": "sha512-nF7oMeL4KypldrQhac8RyHerJeGPD1p2xDh900GPvc+Nk7nWP6jX2FcC7WmkinMoAmoO774+AFXcWsW8gMWEIg==",
+      "requires": {
+        "@apidevtools/swagger-parser": "10.0.3"
+      }
+    },
+    "swagger-ui-dist": {
+      "version": "5.28.1",
+      "resolved": "https://registry.npmjs.org/swagger-ui-dist/-/swagger-ui-dist-5.28.1.tgz",
+      "integrity": "sha512-IvPrtNi8MvjiuDgoSmPYgg27Lvu38fnLD1OSd8Y103xXsPAqezVNnNeHnVCZ/d+CMXJblflGaIyHxAYIF3O71w==",
+      "requires": {
+        "@scarf/scarf": "=1.4.0"
+      }
+    },
+    "swagger-ui-express": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/swagger-ui-express/-/swagger-ui-express-5.0.1.tgz",
+      "integrity": "sha512-SrNU3RiBGTLLmFU8GIJdOdanJTl4TOmT27tt3bWWHppqYmAZ6IDuEuBvMU6nZq0zLEe6b/1rACXCgLZqO6ZfrA==",
+      "requires": {
+        "swagger-ui-dist": ">=5.0.0"
+      }
+    },
+    "tar": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz",
+      "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==",
+      "requires": {
+        "chownr": "^2.0.0",
+        "fs-minipass": "^2.0.0",
+        "minipass": "^5.0.0",
+        "minizlib": "^2.1.1",
+        "mkdirp": "^1.0.3",
+        "yallist": "^4.0.0"
+      }
+    },
+    "tar-fs": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.0.tgz",
+      "integrity": "sha512-5Mty5y/sOF1YWj1J6GiBodjlDc05CUR8PKXrsnFAiSG0xA+GHeWLovaZPYUDXkH/1iKRf2+M5+OrRgzC7O9b7w==",
+      "requires": {
+        "bare-fs": "^4.0.1",
+        "bare-path": "^3.0.0",
+        "pump": "^3.0.0",
+        "tar-stream": "^3.1.5"
+      }
+    },
+    "tar-stream": {
+      "version": "3.1.7",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.7.tgz",
+      "integrity": "sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==",
+      "requires": {
+        "b4a": "^1.6.4",
+        "fast-fifo": "^1.2.0",
+        "streamx": "^2.15.0"
+      }
+    },
+    "text-decoder": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.3.tgz",
+      "integrity": "sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==",
+      "requires": {
+        "b4a": "^1.6.4"
+      }
+    },
+    "to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "requires": {
+        "is-number": "^7.0.0"
+      }
+    },
+    "toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA=="
+    },
+    "touch": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.1.tgz",
+      "integrity": "sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==",
+      "dev": true
+    },
+    "tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="
+    },
+    "tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="
+    },
+    "type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "requires": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      }
+    },
+    "typed-query-selector": {
+      "version": "2.12.0",
+      "resolved": "https://registry.npmjs.org/typed-query-selector/-/typed-query-selector-2.12.0.tgz",
+      "integrity": "sha512-SbklCd1F0EiZOyPiW192rrHZzZ5sBijB6xM+cpmrwDqObvdtunOHHIk9fCGsoK5JVIYXoyEp4iEdE3upFH3PAg=="
+    },
+    "uid-safe": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/uid-safe/-/uid-safe-2.1.5.tgz",
+      "integrity": "sha512-KPHm4VL5dDXKz01UuEd88Df+KzynaohSL9fBh096KWAxSKZQDI2uBrVqtvRM4rwrIrRRKsdLNML/lnaaVSRioA==",
+      "requires": {
+        "random-bytes": "~1.0.0"
+      }
+    },
+    "uid2": {
+      "version": "0.0.4",
+      "resolved": "https://registry.npmjs.org/uid2/-/uid2-0.0.4.tgz",
+      "integrity": "sha512-IevTus0SbGwQzYh3+fRsAMTVVPOoIVufzacXcHPmdlle1jUpq7BRL+mw3dgeLanvGZdwwbWhRV6XrcFNdBmjWA=="
+    },
+    "undefsafe": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.5.tgz",
+      "integrity": "sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==",
+      "dev": true
+    },
+    "undici-types": {
+      "version": "7.10.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.10.0.tgz",
+      "integrity": "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag=="
+    },
+    "unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="
+    },
+    "uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "requires": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="
+    },
+    "utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA=="
+    },
+    "uuid": {
+      "version": "12.0.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-12.0.0.tgz",
+      "integrity": "sha512-USe1zesMYh4fjCA8ZH5+X5WIVD0J4V1Jksm1bFTVBX2F/cwSXt0RO5w/3UXbdLKmZX65MiWV+hwhSS8p6oBTGA=="
+    },
+    "validator": {
+      "version": "13.15.15",
+      "resolved": "https://registry.npmjs.org/validator/-/validator-13.15.15.tgz",
+      "integrity": "sha512-BgWVbCI72aIQy937xbawcs+hrVaN/CZ2UwutgaJ36hGqRrLNM+f5LUT/YPRbo8IV/ASeFzXszezV+y2+rq3l8A=="
+    },
+    "vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="
+    },
+    "web-push": {
+      "version": "3.6.7",
+      "resolved": "https://registry.npmjs.org/web-push/-/web-push-3.6.7.tgz",
+      "integrity": "sha512-OpiIUe8cuGjrj3mMBFWY+e4MMIkW3SVT+7vEIjvD9kejGUypv8GPDf84JdPWskK8zMRIJ6xYGm+Kxr8YkPyA0A==",
+      "requires": {
+        "asn1.js": "^5.3.0",
+        "http_ece": "1.2.0",
+        "https-proxy-agent": "^7.0.0",
+        "jws": "^4.0.0",
+        "minimist": "^1.2.5"
+      },
+      "dependencies": {
+        "agent-base": {
+          "version": "7.1.4",
+          "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+          "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ=="
+        },
+        "debug": {
+          "version": "4.4.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+          "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+          "requires": {
+            "ms": "^2.1.3"
+          }
+        },
+        "https-proxy-agent": {
+          "version": "7.0.6",
+          "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+          "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+          "requires": {
+            "agent-base": "^7.1.2",
+            "debug": "4"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
+      }
+    },
+    "webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="
+    },
+    "whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "requires": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "requires": {
+        "isexe": "^2.0.0"
+      }
+    },
+    "wide-align": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz",
+      "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==",
+      "requires": {
+        "string-width": "^1.0.2 || 2 || 3 || 4"
+      }
+    },
+    "wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "requires": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      }
+    },
+    "wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
+    },
+    "ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "requires": {}
+    },
+    "xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="
+    },
+    "y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA=="
+    },
+    "yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
+    },
+    "yaml": {
+      "version": "2.0.0-1",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.0.0-1.tgz",
+      "integrity": "sha512-W7h5dEhywMKenDJh2iX/LABkbFnBxasD27oyXWDS/feDsxiw0dD5ncXdYXgkvAsXIY2MpW/ZKkr9IU30DBdMNQ=="
+    },
+    "yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "requires": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      }
+    },
+    "yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw=="
+    },
+    "yauzl": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
+      "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
+      "requires": {
+        "buffer-crc32": "~0.2.3",
+        "fd-slicer": "~1.1.0"
+      }
+    },
+    "z-schema": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/z-schema/-/z-schema-5.0.5.tgz",
+      "integrity": "sha512-D7eujBWkLa3p2sIpJA0d1pr7es+a7m0vFAnZLlCEKq/Ij2k0MLi9Br2UPxoxdYystm5K1yeBGzub0FlYUEWj2Q==",
+      "requires": {
+        "commander": "^9.4.1",
+        "lodash.get": "^4.4.2",
+        "lodash.isequal": "^4.5.0",
+        "validator": "^13.7.0"
+      },
+      "dependencies": {
+        "commander": {
+          "version": "9.5.0",
+          "resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
+          "integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",
+          "optional": true
+        }
+      }
+    },
+    "zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="
+    },
+    "zod-to-json-schema": {
+      "version": "3.24.6",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.24.6.tgz",
+      "integrity": "sha512-h/z3PKvcTcTetyjl1fkj79MHNEjm+HpD6NXheWjzOekY7kV+lwDYnHw+ivHkijnCSMz1yJaWBD9vu/Fcmk+vEg==",
+      "requires": {}
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..a75f818
--- /dev/null
+++ b/package.json
@@ -0,0 +1,47 @@
+{
+  "name": "lizenz-generator",
+  "version": "1.0.0",
+  "description": "Lizenzgenerator mit PostgreSQL Integration",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js",
+    "init-db": "node scripts/init-db.js",
+    "create-user": "node scripts/create-user.js",
+    "test-achievements": "node scripts/test-achievements.js",
+    "test-immediate-achievements": "node scripts/test-immediate-achievements.js",
+    "simulate-new-time": "node scripts/simulate-new-time.js",
+    "test-multiple-achievements": "node scripts/test-multiple-achievements.js"
+  },
+  "dependencies": {
+    "@hisma/server-puppeteer": "^0.6.5",
+    "bcrypt": "^5.1.1",
+    "discord-oauth2": "^2.12.1",
+    "dotenv": "^16.3.1",
+    "enhanced-postgres-mcp-server": "^1.0.1",
+    "express": "^4.18.2",
+    "express-session": "^1.17.3",
+    "https": "^1.0.0",
+    "node-cron": "^4.2.1",
+    "passport": "^0.7.0",
+    "passport-discord": "^0.1.4",
+    "pg": "^8.11.3",
+    "socket.io": "^4.8.1",
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^5.0.1",
+    "uuid": "^12.0.0",
+    "web-push": "^3.6.7"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.1"
+  },
+  "keywords": [
+    "license",
+    "generator",
+    "postgresql",
+    "api",
+    "token"
+  ],
+  "author": "Carsten Graf",
+  "license": "propriatary"
+}
diff --git a/pentest/enumerate.py b/pentest/enumerate.py
new file mode 100644
index 0000000..7878fed
--- /dev/null
+++ b/pentest/enumerate.py
@@ -0,0 +1,187 @@
+import requests
+import uuid
+import time
+import json
+from datetime import datetime
+
+def enumerate_supabase_users():
+    base_url = "http://localhost:3000/api/v1/public/user-player"
+    found_users = []
+    total_requests = 0
+    
+    print("🔍 STARTE USER ENUMERATION ÜBER SUPABASE USER IDS")
+    print("=" * 60)
+    print(f"Zeit: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print(f"Target: {base_url}")
+    print("=" * 60)
+    
+    # Teste verschiedene UUID-Patterns
+    test_uuids = [
+        str(uuid.uuid4()) for _ in range(1000)  # Zufällige UUIDs
+    ]
+    
+    print(f"📊 Teste {len(test_uuids)} UUIDs...")
+    print("-" * 60)
+    
+    for i, uuid_str in enumerate(test_uuids, 1):
+        try:
+            response = requests.get(f"{base_url}/{uuid_str}", timeout=5)
+            total_requests += 1
+            
+            if response.status_code == 200:
+                user_data = response.json()
+                if user_data.get("success"):
+                    found_users.append(user_data["data"])
+                    user = user_data["data"]
+                    print(f"✅ [{i:4d}] USER GEFUNDEN!")
+                    print(f"    UUID: {uuid_str}")
+                    print(f"    Name: {user['firstname']} {user['lastname']}")
+                    print(f"    ID: {user['id']}")
+                    print(f"    RFID: {user['rfiduid']}")
+                    print(f"    Geburtsdatum: {user['birthdate']}")
+                    print(f"    Leaderboard: {user['show_in_leaderboard']}")
+                    print("-" * 60)
+                else:
+                    if i % 100 == 0:  # Fortschritt alle 100 Requests
+                        print(f"⏳ [{i:4d}] Kein User gefunden (Fortschritt: {i}/{len(test_uuids)})")
+            else:
+                if i % 100 == 0:
+                    print(f"❌ [{i:4d}] HTTP {response.status_code} (Fortschritt: {i}/{len(test_uuids)})")
+                    
+        except requests.exceptions.RequestException as e:
+            print(f"🔥 [{i:4d}] Fehler bei UUID {uuid_str}: {e}")
+            continue
+    
+    print("\n" + "=" * 60)
+    print("📈 ENUMERATION ABGESCHLOSSEN")
+    print("=" * 60)
+    print(f"Total Requests: {total_requests}")
+    print(f"Gefundene Users: {len(found_users)}")
+    print(f"Erfolgsrate: {(len(found_users)/total_requests*100):.2f}%" if total_requests > 0 else "0%")
+    
+    if found_users:
+        print("\n🎯 GEFUNDENE USERS:")
+        print("-" * 60)
+        for i, user in enumerate(found_users, 1):
+            print(f"{i}. {user['firstname']} {user['lastname']}")
+            print(f"   ID: {user['id']} | RFID: {user['rfiduid']} | Geburtstag: {user['birthdate']}")
+        print("-" * 60)
+        
+        # Speichere Ergebnisse in Datei
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"enumerated_users_{timestamp}.json"
+        with open(filename, 'w', encoding='utf-8') as f:
+            json.dump(found_users, f, indent=2, ensure_ascii=False)
+        print(f"💾 Ergebnisse gespeichert in: {filename}")
+    else:
+        print("\n❌ Keine Users gefunden")
+    
+    print(f"\n⏰ Abgeschlossen um: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    return found_users
+
+def enumerate_rfid_uids(api_key, max_attempts=100):
+    """RFID UID Enumeration (benötigt gültigen API-Key)"""
+    base_url = "http://localhost:3000/api/v1/private/users/find"
+    found_rfids = []
+    
+    print("\n🔍 STARTE RFID UID ENUMERATION")
+    print("=" * 60)
+    print(f"Zeit: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print(f"Target: {base_url}")
+    print(f"API-Key: {api_key[:10]}...")
+    print("=" * 60)
+    
+    # Generiere RFID UIDs zum Testen
+    for i in range(1, max_attempts + 1):
+        # Generiere RFID im Format AA:BB:CC:XX
+        rfid_uid = f"AA:BB:CC:{i:02X}"
+        
+        try:
+            response = requests.post(
+                base_url,
+                headers={
+                    "Authorization": f"Bearer {api_key}",
+                    "Content-Type": "application/json"
+                },
+                json={"uid": rfid_uid},
+                timeout=5
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data.get("success") and data.get("data", {}).get("exists"):
+                    found_rfids.append(data["data"])
+                    user = data["data"]
+                    print(f"✅ [{i:3d}] RFID GEFUNDEN!")
+                    print(f"    RFID: {rfid_uid}")
+                    print(f"    Name: {user['firstname']} {user['lastname']}")
+                    print(f"    Alter: {user['alter']}")
+                    print("-" * 60)
+                else:
+                    if i % 20 == 0:  # Fortschritt alle 20 Requests
+                        print(f"⏳ [{i:3d}] Kein User für RFID {rfid_uid}")
+            else:
+                print(f"❌ [{i:3d}] HTTP {response.status_code} für RFID {rfid_uid}")
+                
+        except requests.exceptions.RequestException as e:
+            print(f"🔥 [{i:3d}] Fehler bei RFID {rfid_uid}: {e}")
+            continue
+    
+    print("\n📈 RFID ENUMERATION ABGESCHLOSSEN")
+    print(f"Gefundene RFIDs: {len(found_rfids)}")
+    
+    return found_rfids
+
+def test_admin_login():
+    """Teste Admin Login Enumeration"""
+    base_url = "http://localhost:3000/api/v1/public/login"
+    
+    # Häufige Admin-Usernamen
+    admin_usernames = [
+        "admin", "administrator", "root", "user", "test", "demo",
+        "admin1", "admin2", "superuser", "manager", "operator"
+    ]
+    
+    print("\n🔍 TESTE ADMIN LOGIN ENUMERATION")
+    print("=" * 60)
+    
+    for username in admin_usernames:
+        try:
+            start_time = time.time()
+            response = requests.post(
+                base_url,
+                json={"username": username, "password": "wrongpassword"},
+                timeout=5
+            )
+            end_time = time.time()
+            response_time = (end_time - start_time) * 1000  # in ms
+            
+            print(f"👤 {username:12} | Status: {response.status_code:3d} | Zeit: {response_time:6.1f}ms")
+            
+            if response.status_code == 200:
+                print(f"    ⚠️  MÖGLICHERWEISE GÜLTIGER USERNAME!")
+                
+        except Exception as e:
+            print(f"🔥 Fehler bei {username}: {e}")
+
+# Führe Enumeration aus
+if __name__ == "__main__":
+    print("🚨 NINJA SERVER SECURITY AUDIT - USER ENUMERATION")
+    print("⚠️  WARNUNG: Nur für autorisierte Sicherheitstests!")
+    print()
+    
+    # 1. Supabase User ID Enumeration
+    found_users = enumerate_supabase_users()
+    
+    # 2. Admin Login Test
+    test_admin_login()
+    
+    # 3. RFID Enumeration (nur mit gültigem API-Key)
+    api_key = input("\n🔑 API-Key für RFID Enumeration eingeben (oder Enter zum Überspringen): ").strip()
+    if api_key:
+        enumerate_rfid_uids(api_key, 50)  # Teste nur 50 RFIDs
+    else:
+        print("⏭️  RFID Enumeration übersprungen")
+    
+    print("\n🏁 AUDIT ABGESCHLOSSEN")
\ No newline at end of file
diff --git a/pentest/realistic_enumeration.py b/pentest/realistic_enumeration.py
new file mode 100644
index 0000000..f1c2f31
--- /dev/null
+++ b/pentest/realistic_enumeration.py
@@ -0,0 +1,312 @@
+import requests
+import time
+import json
+from datetime import datetime
+import statistics
+
+def test_admin_login_timing():
+    """Detaillierte Timing-Analyse für Admin Login"""
+    base_url = "http://localhost:3000/api/v1/public/login"
+    
+    # Erweiterte Liste von Admin-Usernamen
+    admin_usernames = [
+        "admin", "administrator", "root", "user", "test", "demo",
+        "admin1", "admin2", "superuser", "manager", "operator",
+        "ninja", "parkour", "system", "api", "service",
+        "backup", "support", "helpdesk", "it", "tech"
+    ]
+    
+    print("🔍 DETAILLIERTE ADMIN LOGIN TIMING-ANALYSE")
+    print("=" * 70)
+    print(f"Zeit: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print(f"Target: {base_url}")
+    print("=" * 70)
+    
+    results = []
+    
+    # Teste jeden Username mehrfach für bessere Statistik
+    for username in admin_usernames:
+        times = []
+        
+        print(f"\n👤 Testing: {username}")
+        print("-" * 50)
+        
+        for attempt in range(5):  # 5 Versuche pro Username
+            try:
+                start_time = time.time()
+                response = requests.post(
+                    base_url,
+                    json={"username": username, "password": "wrongpassword123"},
+                    timeout=10
+                )
+                end_time = time.time()
+                response_time = (end_time - start_time) * 1000  # in ms
+                times.append(response_time)
+                
+                print(f"  Attempt {attempt+1}: {response_time:6.1f}ms | Status: {response.status_code}")
+                
+                # Kleine Pause zwischen Requests
+                time.sleep(0.1)
+                
+            except Exception as e:
+                print(f"  Attempt {attempt+1}: ERROR - {e}")
+                continue
+        
+        if times:
+            avg_time = statistics.mean(times)
+            std_dev = statistics.stdev(times) if len(times) > 1 else 0
+            min_time = min(times)
+            max_time = max(times)
+            
+            results.append({
+                'username': username,
+                'avg_time': avg_time,
+                'std_dev': std_dev,
+                'min_time': min_time,
+                'max_time': max_time,
+                'times': times,
+                'suspicious': avg_time > 50  # Verdächtig wenn > 50ms
+            })
+            
+            print(f"  📊 Stats: Avg={avg_time:.1f}ms, Std={std_dev:.1f}ms, Range={min_time:.1f}-{max_time:.1f}ms")
+            
+            if avg_time > 50:
+                print(f"  ⚠️  SUSPEKT: Deutlich längere Response-Zeit!")
+    
+    # Sortiere nach durchschnittlicher Response-Zeit
+    results.sort(key=lambda x: x['avg_time'], reverse=True)
+    
+    print("\n" + "=" * 70)
+    print("📈 TIMING-ANALYSE ERGEBNISSE")
+    print("=" * 70)
+    
+    print(f"{'Username':<15} {'Avg(ms)':<8} {'Std(ms)':<8} {'Min(ms)':<8} {'Max(ms)':<8} {'Status'}")
+    print("-" * 70)
+    
+    for result in results:
+        status = "⚠️ SUSPEKT" if result['suspicious'] else "✅ Normal"
+        print(f"{result['username']:<15} {result['avg_time']:<8.1f} {result['std_dev']:<8.1f} "
+              f"{result['min_time']:<8.1f} {result['max_time']:<8.1f} {status}")
+    
+    # Speichere detaillierte Ergebnisse
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"timing_analysis_{timestamp}.json"
+    with open(filename, 'w', encoding='utf-8') as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+    print(f"\n💾 Detaillierte Ergebnisse gespeichert in: {filename}")
+    
+    return results
+
+def test_rfid_creation_enumeration():
+    """Teste RFID Enumeration über Spieler-Erstellung"""
+    base_url = "http://localhost:3000/api/v1/public/players/create-with-rfid"
+    
+    print("\n🔍 RFID ENUMERATION ÜBER SPIELER-ERSTELLUNG")
+    print("=" * 70)
+    print(f"Zeit: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print(f"Target: {base_url}")
+    print("=" * 70)
+    
+    found_rfids = []
+    
+    # Teste verschiedene RFID-Patterns
+    test_patterns = [
+        "AA:BB:CC:DD", "AA:BB:CC:DE", "AA:BB:CC:DF",
+        "11:22:33:44", "11:22:33:45", "11:22:33:46",
+        "FF:FF:FF:FF", "00:00:00:00", "12:34:56:78",
+        "AB:CD:EF:12", "DE:AD:BE:EF", "CA:FE:BA:BE"
+    ]
+    
+    for i, rfid in enumerate(test_patterns, 1):
+        try:
+            payload = {
+                "rfiduid": rfid,
+                "firstname": "Test",
+                "lastname": "User",
+                "birthdate": "1990-01-01"
+            }
+            
+            response = requests.post(base_url, json=payload, timeout=5)
+            
+            print(f"[{i:2d}] RFID: {rfid:<12} | Status: {response.status_code:3d}", end="")
+            
+            if response.status_code == 400:
+                try:
+                    data = response.json()
+                    if "existiert bereits" in data.get("message", ""):
+                        print(" | ✅ EXISTIERT!")
+                        if "existingPlayer" in data.get("details", {}):
+                            existing = data["details"]["existingPlayer"]
+                            found_rfids.append({
+                                "rfid": rfid,
+                                "existing_player": existing
+                            })
+                            print(f"      → Name: {existing.get('firstname')} {existing.get('lastname')}")
+                    else:
+                        print(" | ❌ Anderer Fehler")
+                except:
+                    print(" | ❌ JSON Parse Error")
+            else:
+                print(" | ⚠️  Unexpected Status")
+                
+        except Exception as e:
+            print(f"[{i:2d}] RFID: {rfid:<12} | ERROR: {e}")
+    
+    print(f"\n📊 RFID Enumeration abgeschlossen: {len(found_rfids)} gefunden")
+    return found_rfids
+
+def test_leaderboard_data_leak():
+    """Teste Leaderboard auf sensible Daten"""
+    base_url = "http://localhost:3000/api/v1/public/times-with-details"
+    
+    print("\n🔍 LEADERBOARD DATENLEAK-TEST")
+    print("=" * 70)
+    print(f"Zeit: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print(f"Target: {base_url}")
+    print("=" * 70)
+    
+    try:
+        response = requests.get(base_url, timeout=10)
+        
+        print(f"Status: {response.status_code}")
+        
+        if response.status_code == 200:
+            data = response.json()
+            
+            if isinstance(data, list) and len(data) > 0:
+                print(f"✅ Leaderboard-Daten gefunden: {len(data)} Einträge")
+                
+                # Analysiere erste paar Einträge
+                for i, entry in enumerate(data[:3]):
+                    print(f"\n📋 Eintrag {i+1}:")
+                    if 'player' in entry:
+                        player = entry['player']
+                        print(f"   Name: {player.get('firstname')} {player.get('lastname')}")
+                        print(f"   RFID: {player.get('rfiduid')}")
+                        print(f"   ID: {player.get('id')}")
+                    
+                    if 'location' in entry:
+                        location = entry['location']
+                        print(f"   Location: {location.get('name')}")
+                        print(f"   Koordinaten: {location.get('latitude')}, {location.get('longitude')}")
+                    
+                    if 'recorded_time_seconds' in entry:
+                        print(f"   Zeit: {entry['recorded_time_seconds']} Sekunden")
+                
+                # Speichere alle Daten
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                filename = f"leaderboard_data_{timestamp}.json"
+                with open(filename, 'w', encoding='utf-8') as f:
+                    json.dump(data, f, indent=2, ensure_ascii=False)
+                print(f"\n💾 Leaderboard-Daten gespeichert in: {filename}")
+                
+                return data
+            else:
+                print("❌ Keine Leaderboard-Daten gefunden")
+        else:
+            print(f"❌ Fehler: HTTP {response.status_code}")
+            
+    except Exception as e:
+        print(f"🔥 Fehler beim Abrufen der Leaderboard-Daten: {e}")
+    
+    return None
+
+def test_error_message_analysis():
+    """Analysiere Error Messages auf Information Leakage"""
+    base_url = "http://localhost:3000/api/v1/public/user-player"
+    
+    print("\n🔍 ERROR MESSAGE ANALYSE")
+    print("=" * 70)
+    
+    test_uuids = [
+        "00000000-0000-0000-0000-000000000000",  # Null UUID
+        "invalid-uuid-format",                   # Ungültiges Format
+        "12345678-1234-1234-1234-123456789012", # Gültiges Format, aber wahrscheinlich nicht existent
+        "../../../etc/passwd",                  # Path Traversal
+        "<script>alert('xss')</script>",        # XSS Test
+        "'; DROP TABLE players; --"             # SQL Injection Test
+    ]
+    
+    error_responses = {}
+    
+    for i, test_input in enumerate(test_uuids, 1):
+        try:
+            response = requests.get(f"{base_url}/{test_input}", timeout=5)
+            
+            status_code = response.status_code
+            
+            print(f"[{i}] Input: {test_input:<30} | Status: {status_code}")
+            
+            if status_code not in error_responses:
+                error_responses[status_code] = []
+            
+            try:
+                json_data = response.json()
+                error_responses[status_code].append({
+                    'input': test_input,
+                    'response': json_data
+                })
+            except:
+                error_responses[status_code].append({
+                    'input': test_input,
+                    'response': response.text[:200]  # Erste 200 Zeichen
+                })
+                
+        except Exception as e:
+            print(f"[{i}] Input: {test_input:<30} | ERROR: {e}")
+    
+    # Analysiere verschiedene Error-Messages
+    print(f"\n📊 Error-Message Analyse:")
+    print("-" * 50)
+    
+    for status_code, responses in error_responses.items():
+        print(f"Status {status_code}: {len(responses)} Responses")
+        
+        # Prüfe auf unterschiedliche Error-Messages
+        unique_messages = set()
+        for resp in responses:
+            if isinstance(resp['response'], dict):
+                message = resp['response'].get('message', 'No message')
+            else:
+                message = str(resp['response'])[:100]
+            unique_messages.add(message)
+        
+        print(f"  Unique messages: {len(unique_messages)}")
+        for msg in list(unique_messages)[:3]:  # Zeige erste 3
+            print(f"    - {msg}")
+    
+    return error_responses
+
+if __name__ == "__main__":
+    print("🚨 NINJA SERVER - REALISTISCHE SICHERHEITSTESTS")
+    print("⚠️  WARNUNG: Nur für autorisierte Sicherheitstests!")
+    print()
+    
+    # 1. Admin Login Timing Analysis
+    timing_results = test_admin_login_timing()
+    
+    # 2. RFID Enumeration über Spieler-Erstellung
+    rfid_results = test_rfid_creation_enumeration()
+    
+    # 3. Leaderboard Datenleak-Test
+    leaderboard_data = test_leaderboard_data_leak()
+    
+    # 4. Error Message Analysis
+    error_analysis = test_error_message_analysis()
+    
+    print("\n" + "=" * 70)
+    print("🏁 REALISTISCHE SICHERHEITSTESTS ABGESCHLOSSEN")
+    print("=" * 70)
+    
+    # Zusammenfassung
+    suspicious_users = [r for r in timing_results if r['suspicious']]
+    print(f"🔍 Timing-Suspicious Users: {len(suspicious_users)}")
+    print(f"🔍 Gefundene RFIDs: {len(rfid_results)}")
+    print(f"🔍 Leaderboard-Einträge: {len(leaderboard_data) if leaderboard_data else 0}")
+    
+    if suspicious_users:
+        print(f"\n⚠️  SUSPEKTE USERNAMES (Timing):")
+        for user in suspicious_users:
+            print(f"   - {user['username']}: {user['avg_time']:.1f}ms")
+    
+    print(f"\n⏰ Abgeschlossen um: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
diff --git a/public/404.html b/public/404.html
new file mode 100644
index 0000000..8de5af0
--- /dev/null
+++ b/public/404.html
@@ -0,0 +1,336 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>404 - Seite nicht gefunden | NinjaCross</title>
+    <link rel="icon" type="image/x-icon" href="/pictures/favicon.ico">
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%);
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            overflow: hidden;
+            position: relative;
+        }
+
+        /* Animated background particles */
+        .particles {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            overflow: hidden;
+            z-index: 1;
+        }
+
+        .particle {
+            position: absolute;
+            background: rgba(255, 255, 255, 0.1);
+            border-radius: 50%;
+            animation: float 6s ease-in-out infinite;
+        }
+
+        .particle:nth-child(1) { width: 4px; height: 4px; left: 10%; animation-delay: 0s; }
+        .particle:nth-child(2) { width: 6px; height: 6px; left: 20%; animation-delay: 1s; }
+        .particle:nth-child(3) { width: 3px; height: 3px; left: 30%; animation-delay: 2s; }
+        .particle:nth-child(4) { width: 5px; height: 5px; left: 40%; animation-delay: 3s; }
+        .particle:nth-child(5) { width: 4px; height: 4px; left: 50%; animation-delay: 4s; }
+        .particle:nth-child(6) { width: 7px; height: 7px; left: 60%; animation-delay: 5s; }
+        .particle:nth-child(7) { width: 3px; height: 3px; left: 70%; animation-delay: 0.5s; }
+        .particle:nth-child(8) { width: 5px; height: 5px; left: 80%; animation-delay: 1.5s; }
+        .particle:nth-child(9) { width: 4px; height: 4px; left: 90%; animation-delay: 2.5s; }
+
+        @keyframes float {
+            0%, 100% { transform: translateY(100vh) rotate(0deg); opacity: 0; }
+            10% { opacity: 1; }
+            90% { opacity: 1; }
+            50% { transform: translateY(-10vh) rotate(180deg); }
+        }
+
+        /* Main container */
+        .container {
+            text-align: center;
+            z-index: 10;
+            position: relative;
+            max-width: 600px;
+            padding: 2rem;
+        }
+
+        /* Ninja emoji with animation */
+        .ninja-emoji {
+            font-size: 8rem;
+            margin-bottom: 1rem;
+            display: inline-block;
+            animation: ninja-bounce 2s ease-in-out infinite;
+            filter: drop-shadow(0 0 20px rgba(0, 255, 255, 0.5));
+        }
+
+        @keyframes ninja-bounce {
+            0%, 100% { transform: translateY(0) rotate(0deg); }
+            25% { transform: translateY(-20px) rotate(-5deg); }
+            50% { transform: translateY(-10px) rotate(0deg); }
+            75% { transform: translateY(-15px) rotate(5deg); }
+        }
+
+        /* 404 number with glow effect */
+        .error-code {
+            font-size: 6rem;
+            font-weight: bold;
+            background: linear-gradient(45deg, #00ffff, #ff00ff, #ffff00, #00ffff);
+            background-size: 400% 400%;
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            animation: gradient-shift 3s ease-in-out infinite;
+            margin-bottom: 1rem;
+            text-shadow: 0 0 30px rgba(0, 255, 255, 0.5);
+        }
+
+        @keyframes gradient-shift {
+            0% { background-position: 0% 50%; }
+            50% { background-position: 100% 50%; }
+            100% { background-position: 0% 50%; }
+        }
+
+        /* Error message */
+        .error-message {
+            font-size: 1.5rem;
+            color: #ffffff;
+            margin-bottom: 2rem;
+            opacity: 0;
+            animation: fade-in-up 1s ease-out 0.5s forwards;
+        }
+
+        @keyframes fade-in-up {
+            from {
+                opacity: 0;
+                transform: translateY(30px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        /* Description */
+        .description {
+            font-size: 1.1rem;
+            color: #b0b0b0;
+            margin-bottom: 3rem;
+            line-height: 1.6;
+            opacity: 0;
+            animation: fade-in-up 1s ease-out 1s forwards;
+        }
+
+        /* Action buttons */
+        .actions {
+            display: flex;
+            gap: 1rem;
+            justify-content: center;
+            flex-wrap: wrap;
+            opacity: 0;
+            animation: fade-in-up 1s ease-out 1.5s forwards;
+        }
+
+        .btn {
+            padding: 12px 24px;
+            border: none;
+            border-radius: 8px;
+            font-size: 1rem;
+            font-weight: 600;
+            text-decoration: none;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            position: relative;
+            overflow: hidden;
+        }
+
+        .btn-primary {
+            background: linear-gradient(135deg, #00ffff, #0080ff);
+            color: white;
+            box-shadow: 0 4px 15px rgba(0, 255, 255, 0.3);
+        }
+
+        .btn-primary:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 20px rgba(0, 255, 255, 0.5);
+        }
+
+        .btn-secondary {
+            background: transparent;
+            color: #00ffff;
+            border: 2px solid #00ffff;
+        }
+
+        .btn-secondary:hover {
+            background: #00ffff;
+            color: #1a1a2e;
+            transform: translateY(-2px);
+        }
+
+        /* Glitch effect for 404 */
+        .glitch {
+            position: relative;
+            display: inline-block;
+        }
+
+        .glitch::before,
+        .glitch::after {
+            content: '404';
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: linear-gradient(45deg, #00ffff, #ff00ff, #ffff00, #00ffff);
+            background-size: 400% 400%;
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+        }
+
+        .glitch::before {
+            animation: glitch-1 0.5s infinite;
+            z-index: -1;
+        }
+
+        .glitch::after {
+            animation: glitch-2 0.5s infinite;
+            z-index: -2;
+        }
+
+        @keyframes glitch-1 {
+            0%, 100% { transform: translate(0); }
+            20% { transform: translate(-2px, 2px); }
+            40% { transform: translate(-2px, -2px); }
+            60% { transform: translate(2px, 2px); }
+            80% { transform: translate(2px, -2px); }
+        }
+
+        @keyframes glitch-2 {
+            0%, 100% { transform: translate(0); }
+            20% { transform: translate(2px, -2px); }
+            40% { transform: translate(2px, 2px); }
+            60% { transform: translate(-2px, -2px); }
+            80% { transform: translate(-2px, 2px); }
+        }
+
+        /* Responsive design */
+        @media (max-width: 768px) {
+            .ninja-emoji { font-size: 6rem; }
+            .error-code { font-size: 4rem; }
+            .error-message { font-size: 1.2rem; }
+            .description { font-size: 1rem; }
+            .actions { flex-direction: column; align-items: center; }
+            .btn { width: 200px; }
+        }
+
+        /* Loading animation for page load */
+        .container {
+            animation: page-load 1s ease-out;
+        }
+
+        @keyframes page-load {
+            from {
+                opacity: 0;
+                transform: scale(0.8);
+            }
+            to {
+                opacity: 1;
+                transform: scale(1);
+            }
+        }
+    </style>
+</head>
+<body>
+    <!-- Animated background particles -->
+    <div class="particles">
+        <div class="particle"></div>
+        <div class="particle"></div>
+        <div class="particle"></div>
+        <div class="particle"></div>
+        <div class="particle"></div>
+        <div class="particle"></div>
+        <div class="particle"></div>
+        <div class="particle"></div>
+        <div class="particle"></div>
+    </div>
+
+    <div class="container">
+        <!-- Animated ninja emoji -->
+        <div class="ninja-emoji">🥷</div>
+        
+        <!-- Glitchy 404 number -->
+        <div class="error-code glitch">404</div>
+        
+        <!-- Error message -->
+        <h1 class="error-message">Oops! Diese Seite ist im Ninja-Modus verschwunden!</h1>
+        
+        <!-- Description -->
+        <p class="description">
+            Die Seite, die du suchst, hat sich wie ein echter Ninja versteckt.<br>
+            Vielleicht ist sie auf einer geheimen Mission oder hat sich in der Dunkelheit versteckt.
+        </p>
+        
+        <!-- Action buttons -->
+        <div class="actions">
+            <a href="/" class="btn btn-primary">🏠 Zur Hauptseite</a>
+            <a href="/dashboard.html" class="btn btn-secondary">📊 Dashboard</a>
+        </div>
+    </div>
+
+    <script>
+        // Add some interactive effects
+        document.addEventListener('mousemove', (e) => {
+            const particles = document.querySelectorAll('.particle');
+            const x = e.clientX / window.innerWidth;
+            const y = e.clientY / window.innerHeight;
+            
+            particles.forEach((particle, index) => {
+                const speed = (index + 1) * 0.5;
+                const xOffset = (x - 0.5) * speed * 20;
+                const yOffset = (y - 0.5) * speed * 20;
+                
+                particle.style.transform = `translate(${xOffset}px, ${yOffset}px)`;
+            });
+        });
+
+        // Add click effect on ninja emoji
+        document.querySelector('.ninja-emoji').addEventListener('click', () => {
+            const ninja = document.querySelector('.ninja-emoji');
+            ninja.style.animation = 'none';
+            ninja.style.transform = 'scale(1.2) rotate(360deg)';
+            
+            setTimeout(() => {
+                ninja.style.animation = 'ninja-bounce 2s ease-in-out infinite';
+                ninja.style.transform = '';
+            }, 500);
+        });
+
+        // Add some console easter egg
+        console.log(`
+        🥷 NINJA 404 CONSOLE EASTER EGG 🥷
+        
+        Du hast die geheime Konsole gefunden!
+        Hier ist ein Ninja-Haiku für dich:
+        
+        "Versteckte Seite
+        Wie ein Ninja in der Nacht
+        Kehrt bald zurück"
+        
+        - Der NinjaCross Server
+        `);
+    </script>
+</body>
+</html>
diff --git a/public/admin-dashboard.html b/public/admin-dashboard.html
new file mode 100644
index 0000000..bcc6aa3
--- /dev/null
+++ b/public/admin-dashboard.html
@@ -0,0 +1,254 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Admin Dashboard - NinjaCross</title>
+    <link rel="icon" type="image/x-icon" href="/pictures/favicon.ico">
+    <link rel="stylesheet" href="/css/admin-dashboard.css">
+</head>
+<body>
+    <div class="header">
+        <h1>🛡️ Admin Dashboard</h1>
+        <div class="user-info">
+            <span id="username">Loading...</span>
+            <span id="accessBadge" class="access-badge">Level ?</span>
+            <button id="generatorBtn" class="btn btn-success" style="display: none;">
+                🔧 Lizenzgenerator
+            </button>
+            <button id="logoutBtn" class="btn btn-danger">Logout</button>
+        </div>
+    </div>
+
+    <div class="container">
+        <!-- Statistiken -->
+        <div class="stats-grid">
+            <div class="stat-card">
+                <div class="stat-number" id="totalPlayers">-</div>
+                <div class="stat-label">Spieler</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-number" id="totalRuns">-</div>
+                <div class="stat-label">Läufe</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-number" id="totalLocations">-</div>
+                <div class="stat-label">Standorte</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-number" id="totalAdminUsers">-</div>
+                <div class="stat-label">Admin-Benutzer</div>
+            </div>
+        </div>
+
+        <!-- Hauptseiten-Besuche -->
+        <div class="page-stats-section">
+            <h2>🏠 Hauptseiten-Besuche</h2>
+            <div class="page-stats-grid">
+                <div class="page-stat-card">
+                    <h3>Heute</h3>
+                    <div id="todayStats" class="page-stats-content">Lade...</div>
+                </div>
+                <div class="page-stat-card">
+                    <h3>Diese Woche</h3>
+                    <div id="weekStats" class="page-stats-content">Lade...</div>
+                </div>
+                <div class="page-stat-card">
+                    <h3>Dieser Monat</h3>
+                    <div id="monthStats" class="page-stats-content">Lade...</div>
+                </div>
+                <div class="page-stat-card">
+                    <h3>Gesamt</h3>
+                    <div id="totalStats" class="page-stats-content">Lade...</div>
+                </div>
+            </div>
+            
+            <!-- Verlinkungs-Statistiken -->
+            <div class="link-stats-section">
+                <h3>🔗 Account-Verknüpfungen</h3>
+                <div class="link-stats-grid">
+                    <div class="link-stat-card">
+                        <div class="link-stat-number" id="totalPlayersCount">-</div>
+                        <div class="link-stat-label">Gesamt Spieler</div>
+                    </div>
+                    <div class="link-stat-card">
+                        <div class="link-stat-number" id="linkedPlayersCount">-</div>
+                        <div class="link-stat-label">Verknüpfte Spieler</div>
+                    </div>
+                    <div class="link-stat-card">
+                        <div class="link-stat-number" id="linkPercentage">-</div>
+                        <div class="link-stat-label">Verknüpfungsrate</div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Dashboard Cards -->
+        <div class="dashboard-grid">
+            <!-- Benutzer-Verwaltung -->
+            <div class="card">
+                <h3><span class="icon">👥</span> Benutzer-Verwaltung</h3>
+                <p>Verwalte Supabase-Benutzer und deren RFID-Verknüpfungen</p>
+                <button class="btn" onclick="showUserManagement()">Benutzer anzeigen</button>
+            </div>
+
+            <!-- Spieler-Verwaltung -->
+            <div class="card">
+                <h3><span class="icon">🏃</span> Spieler-Verwaltung</h3>
+                <p>Verwalte Spieler und deren RFID-UIDs</p>
+                <button class="btn" onclick="showPlayerManagement()">Spieler anzeigen</button>
+            </div>
+
+            <!-- Blacklist-Verwaltung -->
+            <div class="card">
+                <h3><span class="icon">🚫</span> Blacklist-Verwaltung</h3>
+                <p>Verwalte verbotene Namen und Begriffe</p>
+                <button class="btn" onclick="showBlacklistManagement()">Blacklist verwalten</button>
+            </div>
+
+
+            <!-- Läufe-Verwaltung -->
+            <div class="card">
+                <h3><span class="icon">⏱️</span> Läufe-Verwaltung</h3>
+                <p>Zeige und lösche Läufe</p>
+                <button class="btn" onclick="showRunManagement()">Läufe anzeigen</button>
+            </div>
+
+            <!-- Standort-Verwaltung -->
+            <div class="card">
+                <h3><span class="icon">📍</span> Standort-Verwaltung</h3>
+                <p>Verwalte Standorte und deren Koordinaten</p>
+                <button class="btn" onclick="showLocationManagement()">Standorte anzeigen</button>
+            </div>
+
+            <!-- Admin-Benutzer -->
+            <div class="card">
+                <h3><span class="icon">🔐</span> Admin-Benutzer</h3>
+                <p>Verwalte Admin-Benutzer und Zugriffsrechte</p>
+                <button class="btn" onclick="showAdminUserManagement()">Admins anzeigen</button>
+            </div>
+
+            <!-- Achievement-Verwaltung -->
+            <div class="card">
+                <h3><span class="icon">🏆</span> Achievement-Verwaltung</h3>
+                <p>Verwalte Achievements und Spieler-Achievements</p>
+                <button class="btn" onclick="showAchievementManagement()">Achievements verwalten</button>
+            </div>
+
+            <!-- System-Info -->
+            <div class="card">
+                <h3><span class="icon">📊</span> System-Informationen</h3>
+                <p>Server-Status und Systemdaten</p>
+                <button class="btn" onclick="showSystemInfo()">Info anzeigen</button>
+            </div>
+        </div>
+
+        <!-- Daten-Anzeige Bereich -->
+        <div id="dataSection" style="display: none;">
+            <div class="card">
+                <h3 id="dataTitle">Daten</h3>
+                <div class="search-container">
+                    <input type="text" id="searchInput" class="search-input" placeholder="Suchen...">
+                    <button class="btn" onclick="refreshData()">🔄 Aktualisieren</button>
+                    <button class="btn btn-success" onclick="showAddModal()">➕ Hinzufügen</button>
+                </div>
+                <div id="dataContent">
+                    <div class="loading">Lade Daten...</div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Modals -->
+    <div id="addModal" class="modal">
+        <div class="modal-content">
+            <span class="close">&times;</span>
+            <h3 id="modalTitle">Element hinzufügen</h3>
+            <div class="message" id="modalMessage"></div>
+            <form id="addForm">
+                <div id="formFields"></div>
+                <button type="submit" class="btn">Speichern</button>
+                <button type="button" class="btn btn-danger" onclick="closeModal()">Abbrechen</button>
+            </form>
+        </div>
+    </div>
+
+    <div id="confirmModal" class="modal">
+        <div class="modal-content">
+            <span class="close">&times;</span>
+            <h3>Bestätigung</h3>
+            <p id="confirmMessage">Sind Sie sicher?</p>
+            <button id="confirmYes" class="btn btn-danger">Ja, löschen</button>
+            <button id="confirmNo" class="btn">Abbrechen</button>
+        </div>
+    </div>
+
+    <!-- Blacklist Management Modal -->
+    <div id="blacklistModal" class="modal">
+        <div class="modal-content" style="max-width: 800px;">
+            <span class="close" onclick="closeModal('blacklistModal')">&times;</span>
+            <h3>🚫 Blacklist-Verwaltung</h3>
+            <div class="message" id="blacklistMessage"></div>
+            
+            <!-- Test Name Section -->
+            <div style="border: 1px solid #ddd; padding: 1rem; margin-bottom: 1rem; border-radius: 5px;">
+                <h4>Name testen</h4>
+                <div style="display: flex; gap: 1rem; margin-bottom: 1rem;">
+                    <input type="text" id="testFirstname" placeholder="Vorname" style="flex: 1; padding: 0.5rem;">
+                    <input type="text" id="testLastname" placeholder="Nachname" style="flex: 1; padding: 0.5rem;">
+                    <button class="btn" onclick="testNameAgainstBlacklist()">Testen</button>
+                    <button class="btn" onclick="testLevenshteinDetailed()" style="background: #9c27b0; color: white;">Levenshtein Details</button>
+                </div>
+                <div id="testResult" style="padding: 0.5rem; border-radius: 3px; display: none;"></div>
+            </div>
+
+            <!-- Add New Entry Section -->
+            <div style="border: 1px solid #ddd; padding: 1rem; margin-bottom: 1rem; border-radius: 5px;">
+                <h4>Neuen Eintrag hinzufügen</h4>
+                <div style="display: flex; gap: 1rem; margin-bottom: 1rem;">
+                    <input type="text" id="newTerm" placeholder="Begriff" style="flex: 1; padding: 0.5rem;">
+                    <select id="newCategory" style="flex: 1; padding: 0.5rem;">
+                        <option value="historical">Historisch belastet</option>
+                        <option value="offensive">Beleidigend/anstößig</option>
+                        <option value="titles">Titel/Berufsbezeichnung</option>
+                        <option value="brands">Markenname</option>
+                        <option value="inappropriate">Unpassend</option>
+                        <option value="racial">Rassistisch/ethnisch</option>
+                        <option value="religious">Religiös beleidigend</option>
+                        <option value="disability">Behinderungsbezogen</option>
+                        <option value="leetspeak">Verschleiert</option>
+                        <option value="cyberbullying">Cyberbullying</option>
+                        <option value="drugs">Drogenbezogen</option>
+                        <option value="violence">Gewalt/Bedrohung</option>
+                    </select>
+                    <button class="btn btn-success" onclick="addToBlacklist()">Hinzufügen</button>
+                </div>
+            </div>
+
+            <!-- Blacklist Content -->
+            <div id="blacklistContent">
+                <div class="loading">Lade Blacklist...</div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-content">
+            <div class="footer-links">
+                <a href="/impressum.html" class="footer-link">Impressum</a>
+                <a href="/datenschutz.html" class="footer-link">Datenschutz</a>
+                <button id="cookie-settings-footer" class="footer-link cookie-settings-btn">Cookie-Einstellungen</button>
+            </div>
+            <div class="footer-text">
+                <p>&copy; 2024 NinjaCross. Alle Rechte vorbehalten.</p>
+            </div>
+        </div>
+    </footer>
+
+
+    <!-- Application JavaScript -->
+    <script src="/js/cookie-consent.js"></script>
+    <script src="/js/admin-dashboard.js"></script>
+</body>
+</html>
diff --git a/public/adminlogin.html b/public/adminlogin.html
new file mode 100644
index 0000000..5d4e36b
--- /dev/null
+++ b/public/adminlogin.html
@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Login - Lizenzgenerator</title>
+    <link rel="icon" type="image/x-icon" href="/pictures/favicon.ico">
+    <link rel="stylesheet" href="/css/adminlogin.css">
+</head>
+<body>
+    <div class="login-container">
+        <h1>🔐 Anmeldung</h1>
+        
+        <form id="loginForm" onsubmit="handleLogin(event)">
+            <div class="form-group">
+                <label for="username">Benutzername</label>
+                <input type="text" id="username" name="username" placeholder="Ihr Benutzername" required>
+            </div>
+
+            <div class="form-group">
+                <label for="password">Passwort</label>
+                <input type="password" id="password" name="password" placeholder="Ihr Passwort" required>
+            </div>
+
+            <button type="submit" class="login-btn" id="loginBtn">
+                <span id="btn-text">Anmelden</span>
+            </button>
+        </form>
+
+        <div id="error" class="error"></div>
+        <div id="success" class="success"></div>
+
+        <div class="info-text">
+            Melden Sie sich an, um auf den Lizenzgenerator zuzugreifen.
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-content">
+            <div class="footer-links">
+                <a href="/impressum.html" class="footer-link">Impressum</a>
+                <a href="/datenschutz.html" class="footer-link">Datenschutz</a>
+                <button id="cookie-settings-footer" class="footer-link cookie-settings-btn">Cookie-Einstellungen</button>
+            </div>
+            <div class="footer-text">
+                <p>&copy; 2024 NinjaCross. Alle Rechte vorbehalten.</p>
+            </div>
+        </div>
+    </footer>
+
+    <script src="/js/cookie-consent.js"></script>
+    <script src="/js/adminlogin.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/public/agb.html b/public/agb.html
new file mode 100644
index 0000000..aadb28b
--- /dev/null
+++ b/public/agb.html
@@ -0,0 +1,244 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Allgemeine Geschäftsbedingungen | NinjaCross</title>
+    <link rel="stylesheet" href="css/dashboard.css">
+    <style>
+        .agb-container {
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+            background: #1e293b;
+            border-radius: 10px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            margin-top: 20px;
+            color: #e2e8f0;
+        }
+        
+        .agb-header {
+            text-align: center;
+            margin-bottom: 30px;
+            padding-bottom: 20px;
+            border-bottom: 2px solid #334155;
+        }
+        
+        .agb-header h1 {
+            color: #00d4ff;
+            margin-bottom: 10px;
+        }
+        
+        .agb-header .subtitle {
+            color: #94a3b8;
+            font-size: 16px;
+        }
+        
+        .agb-content {
+            line-height: 1.6;
+            color: #e2e8f0;
+        }
+        
+        .agb-section {
+            margin-bottom: 25px;
+        }
+        
+        .agb-section h2 {
+            color: #00d4ff;
+            font-size: 20px;
+            margin-bottom: 15px;
+            padding-bottom: 5px;
+            border-bottom: 1px solid #334155;
+        }
+        
+        .agb-section h3 {
+            color: #e2e8f0;
+            font-size: 16px;
+            margin-bottom: 10px;
+            margin-top: 20px;
+        }
+        
+        .agb-section p {
+            margin-bottom: 12px;
+        }
+        
+        .agb-section ul {
+            margin-left: 20px;
+            margin-bottom: 15px;
+        }
+        
+        .agb-section li {
+            margin-bottom: 8px;
+        }
+        
+        .highlight-box {
+            background: #0f172a;
+            border-left: 4px solid #00d4ff;
+            padding: 15px;
+            margin: 20px 0;
+            border-radius: 0 5px 5px 0;
+        }
+        
+        .warning-box {
+            background: #451a03;
+            border-left: 4px solid #fbbf24;
+            padding: 15px;
+            margin: 20px 0;
+            border-radius: 0 5px 5px 0;
+        }
+        
+        .back-button {
+            display: inline-block;
+            background: #00d4ff;
+            color: #0f172a;
+            padding: 12px 24px;
+            text-decoration: none;
+            border-radius: 5px;
+            margin-top: 30px;
+            transition: background-color 0.3s;
+            font-weight: bold;
+        }
+        
+        .back-button:hover {
+            background: #0891b2;
+        }
+        
+        .last-updated {
+            text-align: center;
+            color: #94a3b8;
+            font-style: italic;
+            margin-top: 30px;
+            padding-top: 20px;
+            border-top: 1px solid #334155;
+        }
+    </style>
+</head>
+<body style="background: #0f172a; min-height: 100vh; padding: 20px;">
+    <div class="agb-container">
+        <div class="agb-header">
+            <h1>Allgemeine Geschäftsbedingungen</h1>
+            <p class="subtitle">NinjaCross Parkour System</p>
+        </div>
+        
+        <div class="agb-content">
+            <div class="highlight-box">
+                <strong>Wichtig:</strong> Durch die Nutzung des NinjaCross Systems stimmen Sie zu, dass Ihre Daten 
+                (Name, Zeiten, Standorte) im öffentlichen Leaderboard angezeigt werden können.
+            </div>
+            
+            <div class="agb-section">
+                <h2>1. Geltungsbereich</h2>
+                <p>Diese Allgemeinen Geschäftsbedingungen (AGB) gelten für die Nutzung des NinjaCross Parkour Systems 
+                im Schwimmbad. Mit der Registrierung und Nutzung des Systems erkennen Sie diese AGB als verbindlich an.</p>
+            </div>
+            
+            <div class="agb-section">
+                <h2>2. Datenverarbeitung und Datenschutz</h2>
+                
+                <h3>2.1 Erhebung von Daten</h3>
+                <p>Wir erheben folgende personenbezogene Daten:</p>
+                <ul>
+                    <li>Vor- und Nachname</li>
+                    <li>Geburtsdatum (zur Altersberechnung)</li>
+                    <li>RFID-Kartennummer</li>
+                    <li>Laufzeiten und Standortdaten</li>
+                    <li>Zeitstempel der Aktivitäten</li>
+                </ul>
+                
+                <h3>2.2 Verwendung der Daten</h3>
+                <p>Ihre Daten werden für folgende Zwecke verwendet:</p>
+                <ul>
+                    <li><strong>Leaderboard-Anzeige:</strong> Name, Zeiten und Standorte werden im öffentlichen Leaderboard angezeigt</li>
+                    <li><strong>Leistungsauswertung:</strong> Erfassung und Bewertung Ihrer Parkour-Zeiten</li>
+                    <li><strong>System-Funktionalität:</strong> Zuordnung von Zeiten zu Ihrem Profil über RFID-Karten</li>
+                    <li><strong>Statistiken:</strong> Anonymisierte Auswertungen für Systemverbesserungen</li>
+                </ul>
+                
+                <div class="warning-box">
+                    <strong>Wichtiger Hinweis:</strong> Durch die Annahme dieser AGB stimmen Sie ausdrücklich zu, 
+                    dass Ihr Name und Ihre Laufzeiten im öffentlichen Leaderboard sichtbar sind.
+                </div>
+            </div>
+            
+            <div class="agb-section">
+                <h2>3. Leaderboard und Öffentlichkeit</h2>
+                <p>Das NinjaCross System verfügt über ein öffentlich zugängliches Leaderboard, das folgende Informationen anzeigt:</p>
+                <ul>
+                    <li>Vollständiger Name der Teilnehmer</li>
+                    <li>Erreichte Laufzeiten</li>
+                    <li>Standort der Aktivität</li>
+                    <li>Datum und Uhrzeit der Aktivität</li>
+                </ul>
+                
+                <p><strong>Durch die Nutzung des Systems erklären Sie sich damit einverstanden, dass diese Daten öffentlich angezeigt werden.</strong></p>
+            </div>
+            
+            <div class="agb-section">
+                <h2>4. Ihre Rechte</h2>
+                <h3>4.1 Recht auf Auskunft</h3>
+                <p>Sie haben das Recht, Auskunft über die zu Ihrer Person gespeicherten Daten zu verlangen.</p>
+                
+                <h3>4.2 Recht auf Löschung</h3>
+                <p>Sie können jederzeit die Löschung Ihrer Daten und Ihres Profils beantragen.</p>
+                
+                <h3>4.3 Recht auf Widerspruch</h3>
+                <p>Sie können der Verarbeitung Ihrer Daten für das Leaderboard widersprechen. 
+                In diesem Fall werden Ihre Daten aus dem öffentlichen Leaderboard entfernt, 
+                aber weiterhin für die Systemfunktionalität verwendet.</p>
+            </div>
+            
+            <div class="agb-section">
+                <h2>5. Haftung und Verantwortung</h2>
+                <p>Die Teilnahme am NinjaCross System erfolgt auf eigene Gefahr. Wir haften nicht für:</p>
+                <ul>
+                    <li>Verletzungen während der Nutzung der Parkour-Anlage</li>
+                    <li>Verlust oder Diebstahl der RFID-Karte</li>
+                    <li>Technische Ausfälle des Systems</li>
+                </ul>
+            </div>
+            
+            <div class="agb-section">
+                <h2>6. Systemregeln</h2>
+                <p>Bei der Nutzung des Systems sind folgende Regeln zu beachten:</p>
+                <ul>
+                    <li>Keine Manipulation der Zeiterfassung</li>
+                    <li>Respektvoller Umgang mit anderen Teilnehmern</li>
+                    <li>Beachtung der Sicherheitshinweise der Anlage</li>
+                    <li>Keine Verwendung falscher Identitäten</li>
+                </ul>
+            </div>
+            
+            <div class="agb-section">
+                <h2>7. Änderungen der AGB</h2>
+                <p>Wir behalten uns vor, diese AGB zu ändern. Wesentliche Änderungen werden Ihnen 
+                mitgeteilt und erfordern Ihre erneute Zustimmung.</p>
+            </div>
+            
+            <div class="agb-section">
+                <h2>8. Kontakt</h2>
+                <p>Bei Fragen zu diesen AGB oder zum Datenschutz wenden Sie sich an:</p>
+                <p>
+                    <strong>NinjaCross Team</strong><br>
+                    Schwimmbad Ulm<br>
+                    E-Mail: info@ninjacross.de<br>
+                    Telefon: 0731-123456
+                </p>
+            </div>
+        </div>
+        
+        <div style="text-align: center;">
+            <a href="javascript:history.back()" class="back-button">Zurück</a>
+        </div>
+        
+        <div class="last-updated">
+            <p>Stand: September 2024</p>
+            <p>Diese AGB sind Teil der Registrierung und gelten ab dem Zeitpunkt der Zustimmung.</p>
+        </div>
+    </div>
+</body>
+</html>
+
+
+
+
+
diff --git a/public/css/admin-dashboard.css b/public/css/admin-dashboard.css
new file mode 100644
index 0000000..22b70f8
--- /dev/null
+++ b/public/css/admin-dashboard.css
@@ -0,0 +1,753 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Inter', sans-serif;
+    background: #0a0a0f;
+    color: #ffffff;
+    min-height: 100vh;
+    background-image:
+        radial-gradient(circle at 20% 80%, #1a1a2e 0%, transparent 50%),
+        radial-gradient(circle at 80% 20%, #16213e 0%, transparent 50%),
+        radial-gradient(circle at 40% 40%, #0f3460 0%, transparent 50%);
+}
+
+.header {
+    background: rgba(26, 26, 46, 0.95);
+    padding: 20px;
+    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.3);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.header h1 {
+    color: #ffffff;
+    font-size: 2em;
+}
+
+.user-info {
+    display: flex;
+    align-items: center;
+    gap: 15px;
+}
+
+.access-badge {
+    background: #4CAF50;
+    color: white;
+    padding: 5px 10px;
+    border-radius: 15px;
+    font-size: 0.8em;
+    font-weight: bold;
+}
+
+.access-badge.level-1 {
+    background: #ff9800;
+}
+
+.access-badge.level-2 {
+    background: #4CAF50;
+}
+
+.btn {
+    background: #2196F3;
+    color: white;
+    border: none;
+    padding: 10px 20px;
+    border-radius: 5px;
+    cursor: pointer;
+    text-decoration: none;
+    display: inline-block;
+    font-size: 0.9em;
+    transition: all 0.3s ease;
+}
+
+.btn:hover {
+    background: #1976D2;
+    transform: translateY(-2px);
+}
+
+.btn-danger {
+    background: #f44336;
+}
+
+.btn-danger:hover {
+    background: #d32f2f;
+}
+
+.btn-warning {
+    background: #ff9800;
+}
+
+.btn-warning:hover {
+    background: #f57c00;
+}
+
+.btn-success {
+    background: #4CAF50;
+}
+
+.btn-success:hover {
+    background: #388E3C;
+}
+
+.container {
+    max-width: 1200px;
+    margin: 30px auto;
+    padding: 0 20px;
+}
+
+.dashboard-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 20px;
+    margin-bottom: 30px;
+}
+
+.card {
+    background: rgba(26, 26, 46, 0.95);
+    border-radius: 10px;
+    padding: 20px;
+    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.3);
+    transition: transform 0.3s ease;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.card:hover {
+    transform: translateY(-5px);
+}
+
+.card h3 {
+    color: #00d4ff;
+    margin-bottom: 15px;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+}
+
+.icon {
+    font-size: 1.5em;
+}
+
+.stats-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 15px;
+    margin-bottom: 30px;
+}
+
+.stat-card {
+    background: rgba(26, 26, 46, 0.95);
+    padding: 20px;
+    border-radius: 10px;
+    text-align: center;
+    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.3);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.stat-number {
+    font-size: 2.5em;
+    font-weight: bold;
+    color: #00d4ff;
+    margin-bottom: 5px;
+}
+
+.stat-label {
+    color: #8892b0;
+    font-size: 0.9em;
+}
+
+.data-table {
+    width: 100%;
+    border-collapse: collapse;
+    background: rgba(26, 26, 46, 0.95);
+    border-radius: 10px;
+    overflow: hidden;
+    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.3);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.data-table th,
+.data-table td {
+    padding: 12px;
+    text-align: left;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+    color: #ffffff;
+}
+
+.data-table th {
+    background: rgba(255, 255, 255, 0.1);
+    font-weight: bold;
+    color: #ffffff;
+}
+
+.data-table tr:hover {
+    background: rgba(255, 255, 255, 0.1);
+}
+
+.modal {
+    display: none;
+    position: fixed;
+    z-index: 1000;
+    left: 0;
+    top: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0, 0, 0, 0.5);
+}
+
+.modal-content {
+    background-color: rgba(26, 26, 46, 0.95);
+    margin: 5% auto;
+    padding: 20px;
+    border-radius: 10px;
+    width: 90%;
+    max-width: 500px;
+    max-height: 85vh;
+    overflow-y: auto;
+    position: relative;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.close {
+    color: #8892b0;
+    float: right;
+    font-size: 28px;
+    font-weight: bold;
+    cursor: pointer;
+    position: absolute;
+    right: 15px;
+    top: 10px;
+}
+
+.close:hover {
+    color: #ffffff;
+}
+
+/* Blacklist Modal specific styles */
+#blacklistModal .modal-content {
+    max-width: 800px;
+    max-height: 90vh;
+    overflow-y: auto;
+}
+
+/* Smooth scrolling for modal content */
+.modal-content {
+    scroll-behavior: smooth;
+}
+
+/* Custom scrollbar for modal content */
+.modal-content::-webkit-scrollbar {
+    width: 8px;
+}
+
+.modal-content::-webkit-scrollbar-track {
+    background: rgba(30, 41, 59, 0.3);
+    border-radius: 4px;
+}
+
+.modal-content::-webkit-scrollbar-thumb {
+    background: rgba(100, 116, 139, 0.6);
+    border-radius: 4px;
+}
+
+.modal-content::-webkit-scrollbar-thumb:hover {
+    background: rgba(100, 116, 139, 0.8);
+}
+
+.form-group {
+    margin-bottom: 15px;
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: 5px;
+    font-weight: bold;
+    color: #333;
+}
+
+.form-group input,
+.form-group select {
+    width: 100%;
+    padding: 10px;
+    border: 1px solid #ddd;
+    border-radius: 5px;
+    font-size: 1em;
+}
+
+.message {
+    padding: 10px;
+    border-radius: 5px;
+    margin-bottom: 15px;
+    display: none;
+}
+
+.message.success {
+    background: #d4edda;
+    color: #155724;
+    border: 1px solid #c3e6cb;
+}
+
+.message.error {
+    background: #f8d7da;
+    color: #721c24;
+    border: 1px solid #f5c6cb;
+}
+
+.loading {
+    text-align: center;
+    padding: 20px;
+    color: #666;
+}
+
+.no-data {
+    text-align: center;
+    padding: 40px;
+    color: #999;
+    font-style: italic;
+}
+
+.action-buttons {
+    display: flex;
+    gap: 5px;
+}
+
+.btn-small {
+    padding: 5px 10px;
+    font-size: 0.8em;
+}
+
+.table-container {
+    max-height: 400px;
+    overflow-y: auto;
+    margin-top: 15px;
+}
+
+.search-container {
+    margin-bottom: 20px;
+    display: flex;
+    gap: 10px;
+    align-items: center;
+}
+
+.search-input {
+    flex: 1;
+    padding: 10px;
+    border: 1px solid #ddd;
+    border-radius: 5px;
+}
+
+@media (max-width: 768px) {
+    .header {
+        flex-direction: column;
+        gap: 15px;
+        text-align: center;
+    }
+
+    .dashboard-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .stats-grid {
+        grid-template-columns: repeat(2, 1fr);
+    }
+
+    .search-container {
+        flex-direction: column;
+        align-items: stretch;
+    }
+
+    .action-buttons {
+        flex-direction: column;
+    }
+
+    .modal-content {
+        margin: 5% auto;
+        width: 95%;
+    }
+
+    .page-stats-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .link-stats-grid {
+        grid-template-columns: repeat(2, 1fr);
+    }
+}
+
+/* Page Statistics Styles */
+.page-stats-section {
+    background: rgba(26, 26, 46, 0.95);
+    border-radius: 10px;
+    padding: 25px;
+    margin: 20px 0;
+    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.3);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.page-stats-section h2 {
+    color: #ffffff;
+    margin-bottom: 20px;
+    font-size: 1.5em;
+}
+
+.page-stats-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+    gap: 20px;
+    margin-bottom: 30px;
+}
+
+.page-stat-card {
+    background: rgba(26, 26, 46, 0.95);
+    border-radius: 8px;
+    padding: 20px;
+    border-left: 4px solid #00d4ff;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.page-stat-card h3 {
+    color: #ffffff;
+    margin-bottom: 15px;
+    font-size: 1.2em;
+}
+
+.page-stats-content {
+    font-size: 0.9em;
+    line-height: 1.6;
+    background: rgba(26, 26, 46, 0.95);
+    border-radius: 8px;
+    padding: 15px;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.page-stats-content .page-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 12px 15px;
+    margin: 8px 0;
+    background: rgba(255, 255, 255, 0.05);
+    border-radius: 6px;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    transition: background-color 0.3s ease;
+}
+
+.page-stats-content .page-item:last-child {
+    border-bottom: none;
+}
+
+.page-stats-content .page-item:hover {
+    background: rgba(255, 255, 255, 0.1);
+}
+
+.page-stats-content .page-name {
+    font-weight: 500;
+    color: #ffffff;
+}
+
+.page-stats-content .page-count {
+    background: #00d4ff;
+    color: #00d4ff;
+    padding: 4px 8px;
+    border-radius: 12px;
+    font-size: 0.8em;
+    font-weight: bold;
+}
+
+/* Link Statistics Styles */
+.link-stats-section {
+    background: #1a1a2f;
+    border-radius: 8px;
+    padding: 20px;
+    margin-top: 20px;
+}
+
+.link-stats-section h3 {
+    color: #00d4ff;
+    margin-bottom: 15px;
+    font-size: 1.3em;
+}
+
+.link-stats-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+    gap: 20px;
+}
+
+.link-stat-card {
+    text-align: center;
+    background: rgba(26, 26, 46, 0.95);
+    border-radius: 8px;
+    padding: 20px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.link-stat-number {
+    font-size: 2em;
+    font-weight: bold;
+    color: #00d4ff;
+    margin-bottom: 8px;
+}
+
+.link-stat-label {
+    color: #8892b0;
+    font-size: 0.9em;
+    font-weight: 500;
+}
+
+@media (max-width: 480px) {
+    .stats-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .container {
+        padding: 0 10px;
+    }
+
+    .card {
+        padding: 15px;
+    }
+}
+
+/* Footer Styles */
+.footer {
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    border-top: 1px solid #2a2a3e;
+    margin-top: 3rem;
+    padding: 2rem 0;
+}
+
+.footer-content {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 0 2rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.footer-links {
+    display: flex;
+    gap: 2rem;
+    align-items: center;
+}
+
+.footer-link {
+    color: #8892b0;
+    text-decoration: none;
+    font-size: 0.9rem;
+    transition: color 0.3s ease;
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-family: inherit;
+}
+
+.footer-link:hover {
+    color: #00d4ff;
+}
+
+.cookie-settings-btn {
+    background: none !important;
+    border: none !important;
+    padding: 0 !important;
+    font-size: 0.9rem !important;
+}
+
+.footer-text {
+    color: #6b7280;
+    font-size: 0.85rem;
+}
+
+.footer-text p {
+    margin: 0;
+}
+
+@media (max-width: 768px) {
+    .footer-content {
+        flex-direction: column;
+        text-align: center;
+        gap: 1.5rem;
+    }
+
+    .footer-links {
+        flex-wrap: wrap;
+        justify-content: center;
+        gap: 1.5rem;
+    }
+}
+
+/* Achievement Management Styles */
+.achievement-controls {
+    display: flex;
+    gap: 10px;
+    margin-bottom: 20px;
+    flex-wrap: wrap;
+}
+
+.status-badge {
+    padding: 4px 8px;
+    border-radius: 12px;
+    font-size: 0.8em;
+    font-weight: 500;
+}
+
+.status-badge.active {
+    background: #4ade80;
+    color: #000;
+}
+
+.status-badge.inactive {
+    background: #6b7280;
+    color: #fff;
+}
+
+.progress-bar {
+    position: relative;
+    background: rgba(255, 255, 255, 0.1);
+    border-radius: 10px;
+    height: 20px;
+    overflow: hidden;
+    min-width: 100px;
+}
+
+.progress-fill {
+    background: linear-gradient(90deg, #4ade80, #22c55e);
+    height: 100%;
+    transition: width 0.3s ease;
+}
+
+.progress-text {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    font-size: 0.8em;
+    font-weight: 500;
+    color: #fff;
+    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.5);
+}
+
+.player-achievements {
+    max-height: 70vh;
+    overflow-y: auto;
+}
+
+.achievement-stats {
+    display: flex;
+    gap: 20px;
+    margin-bottom: 20px;
+    padding: 15px;
+    background: rgba(255, 255, 255, 0.05);
+    border-radius: 8px;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.stat-item {
+    font-size: 0.9em;
+}
+
+.achievements-list {
+    display: grid;
+    gap: 15px;
+}
+
+.achievement-item {
+    background: rgba(255, 255, 255, 0.05);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    border-radius: 8px;
+    padding: 15px;
+    transition: all 0.3s ease;
+}
+
+.achievement-item.completed {
+    border-color: #4ade80;
+    background: rgba(74, 222, 128, 0.1);
+}
+
+.achievement-item.not-completed {
+    border-color: #6b7280;
+    background: rgba(107, 114, 128, 0.1);
+}
+
+.achievement-header {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    margin-bottom: 10px;
+}
+
+.achievement-icon {
+    font-size: 1.5em;
+}
+
+.achievement-name {
+    font-weight: 600;
+    flex: 1;
+}
+
+.achievement-status {
+    font-size: 1.2em;
+}
+
+.achievement-details p {
+    margin-bottom: 10px;
+    color: rgba(255, 255, 255, 0.8);
+    line-height: 1.4;
+}
+
+.achievement-meta {
+    display: flex;
+    gap: 15px;
+    margin-bottom: 10px;
+    flex-wrap: wrap;
+}
+
+.achievement-meta span {
+    font-size: 0.8em;
+    color: rgba(255, 255, 255, 0.6);
+    background: rgba(255, 255, 255, 0.1);
+    padding: 2px 8px;
+    border-radius: 4px;
+}
+
+.achievement-actions {
+    display: flex;
+    gap: 10px;
+    justify-content: flex-end;
+}
+
+.achievement-actions .btn {
+    padding: 6px 12px;
+    font-size: 0.8em;
+}
+
+@media (max-width: 768px) {
+    .achievement-controls {
+        flex-direction: column;
+    }
+    
+    .achievement-stats {
+        flex-direction: column;
+        gap: 10px;
+    }
+    
+    .achievement-meta {
+        flex-direction: column;
+        gap: 5px;
+    }
+    
+    .achievement-actions {
+        justify-content: center;
+    }
+}
\ No newline at end of file
diff --git a/public/css/adminlogin.css b/public/css/adminlogin.css
new file mode 100644
index 0000000..06938c2
--- /dev/null
+++ b/public/css/adminlogin.css
@@ -0,0 +1,294 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+html,
+body {
+    height: 100%;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: 'Inter', sans-serif;
+    background: #0a0a0f;
+    color: #ffffff;
+    min-height: 100vh;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 20px;
+    background-image:
+        radial-gradient(circle at 20% 80%, #1a1a2e 0%, transparent 50%),
+        radial-gradient(circle at 80% 20%, #16213e 0%, transparent 50%),
+        radial-gradient(circle at 40% 40%, #0f3460 0%, transparent 50%);
+}
+
+.login-container {
+    background: rgba(26, 26, 46, 0.95);
+    backdrop-filter: blur(10px);
+    border-radius: 20px;
+    box-shadow: 0 20px 40px rgba(0, 0, 0, 0.3);
+    padding: 40px;
+    max-width: 400px;
+    width: 100%;
+    position: relative;
+    overflow: hidden;
+    flex-grow: 1;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.login-container::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    height: 4px;
+    background: linear-gradient(90deg, #667eea, #764ba2, #f093fb, #f5576c);
+    background-size: 300% 100%;
+    animation: gradientShift 3s ease infinite;
+}
+
+@keyframes gradientShift {
+    0% {
+        background-position: 0% 50%;
+    }
+
+    50% {
+        background-position: 100% 50%;
+    }
+
+    100% {
+        background-position: 0% 50%;
+    }
+}
+
+h1 {
+    text-align: center;
+    color: #ffffff;
+    margin-bottom: 30px;
+    font-size: 2em;
+    font-weight: 300;
+    letter-spacing: -1px;
+}
+
+.form-group {
+    margin-bottom: 25px;
+    position: relative;
+}
+
+label {
+    display: block;
+    margin-bottom: 8px;
+    color: #555;
+    font-weight: 500;
+    font-size: 0.95em;
+}
+
+input {
+    width: 100%;
+    padding: 15px 20px;
+    border: 2px solid #e0e0e0;
+    border-radius: 12px;
+    font-size: 1em;
+    transition: all 0.3s ease;
+    background: #fafafa;
+    font-family: inherit;
+}
+
+input:focus {
+    outline: none;
+    border-color: #667eea;
+    background: white;
+    box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+    transform: translateY(-2px);
+}
+
+input:hover {
+    border-color: #ccc;
+}
+
+.login-btn {
+    width: 100%;
+    padding: 18px;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border: none;
+    border-radius: 12px;
+    font-size: 1.1em;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    margin-top: 10px;
+    position: relative;
+    overflow: hidden;
+}
+
+.login-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 10px 25px rgba(102, 126, 234, 0.3);
+}
+
+.login-btn:active {
+    transform: translateY(0);
+}
+
+.login-btn:disabled {
+    opacity: 0.7;
+    cursor: not-allowed;
+    transform: none;
+}
+
+.error {
+    background: #ffebee;
+    color: #c62828;
+    padding: 15px;
+    border-radius: 8px;
+    margin-top: 15px;
+    border-left: 4px solid #f44336;
+    font-size: 0.9em;
+    opacity: 0;
+    transform: translateY(-10px);
+    transition: all 0.3s ease;
+}
+
+.error.show {
+    opacity: 1;
+    transform: translateY(0);
+}
+
+.success {
+    background: #e8f5e8;
+    color: #2e7d32;
+    padding: 15px;
+    border-radius: 8px;
+    margin-top: 15px;
+    border-left: 4px solid #4caf50;
+    font-size: 0.9em;
+    opacity: 0;
+    transform: translateY(-10px);
+    transition: all 0.3s ease;
+}
+
+.success.show {
+    opacity: 1;
+    transform: translateY(0);
+}
+
+.loading {
+    display: inline-block;
+    width: 20px;
+    height: 20px;
+    border: 3px solid rgba(255, 255, 255, .3);
+    border-radius: 50%;
+    border-top-color: #fff;
+    animation: spin 1s ease-in-out infinite;
+    margin-right: 10px;
+}
+
+@keyframes spin {
+    to {
+        transform: rotate(360deg);
+    }
+}
+
+.info-text {
+    text-align: center;
+    color: #666;
+    font-size: 0.85em;
+    margin-top: 20px;
+    line-height: 1.5;
+}
+
+@media (max-width: 480px) {
+    .login-container {
+        padding: 30px 20px;
+        margin: 10px;
+    }
+
+    h1 {
+        font-size: 1.6em;
+    }
+}
+
+/* Footer Styles */
+.footer {
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    border-top: 1px solid #2a2a3e;
+    margin-top: auto;
+    padding: 2rem 0;
+    position: relative;
+    bottom: 0;
+    width: 100%;
+}
+
+.footer-content {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 0 2rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.footer-links {
+    display: flex;
+    gap: 2rem;
+    align-items: center;
+}
+
+.footer-link {
+    color: #8892b0;
+    text-decoration: none;
+    font-size: 0.9rem;
+    transition: color 0.3s ease;
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-family: inherit;
+}
+
+.footer-link:hover {
+    color: #00d4ff;
+}
+
+.cookie-settings-btn {
+    background: none !important;
+    border: none !important;
+    padding: 0 !important;
+    font-size: 0.9rem !important;
+}
+
+.footer-text {
+    color: #6b7280;
+    font-size: 0.85rem;
+}
+
+.footer-text p {
+    margin: 0;
+}
+
+@media (max-width: 768px) {
+    .footer-content {
+        flex-direction: column;
+        text-align: center;
+        gap: 1.5rem;
+    }
+
+    .footer-links {
+        flex-wrap: wrap;
+        justify-content: center;
+        gap: 1.5rem;
+    }
+}
\ No newline at end of file
diff --git a/public/css/dashboard.css b/public/css/dashboard.css
new file mode 100644
index 0000000..5e87dc7
--- /dev/null
+++ b/public/css/dashboard.css
@@ -0,0 +1,1981 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Inter', sans-serif;
+    background: #0a0a0f;
+    color: #ffffff;
+    min-height: 100vh;
+    background-image:
+        radial-gradient(circle at 20% 80%, #1a1a2e 0%, transparent 50%),
+        radial-gradient(circle at 80% 20%, #16213e 0%, transparent 50%),
+        radial-gradient(circle at 40% 40%, #0f3460 0%, transparent 50%);
+}
+
+.main-container {
+    max-width: 1400px;
+    margin: 0 auto;
+    padding: 2rem;
+    min-height: 100vh;
+}
+
+/* Sticky Header Container */
+.sticky-header {
+    position: sticky;
+    top: 0;
+    z-index: 1000;
+    margin-bottom: 2rem;
+    padding: 1rem 2rem;
+    background: rgba(15, 23, 42, 0.95);
+    backdrop-filter: blur(20px);
+    border: 1px solid #1e293b;
+    border-radius: 1rem;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+/* Language Selector */
+.language-selector {
+    display: inline-block;
+}
+
+.language-selector select {
+    padding: 0.5rem 1rem;
+    background: rgba(15, 23, 42, 0.9);
+    border: 1px solid #334155;
+    border-radius: 0.5rem;
+    color: #ffffff;
+    font-size: 0.9rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    backdrop-filter: blur(10px);
+    padding-left: 2.5rem;
+    background-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="20" height="15" viewBox="0 0 20 15"><rect width="20" height="5" fill="%23000000"/><rect y="5" width="20" height="5" fill="%23DD0000"/><rect y="10" width="20" height="5" fill="%23FFCE00"/></svg>');
+    background-repeat: no-repeat;
+    background-position: 0.5rem center;
+    background-size: 20px 15px;
+}
+
+.language-selector select:hover {
+    border-color: #00d4ff;
+    box-shadow: 0 0 0 2px rgba(0, 212, 255, 0.1);
+}
+
+.language-selector select:focus {
+    outline: none;
+    border-color: #00d4ff;
+    box-shadow: 0 0 0 3px rgba(0, 212, 255, 0.2);
+}
+
+.header-section {
+    text-align: center;
+    margin-bottom: 3rem;
+    margin-top: 1rem;
+}
+
+.main-title {
+    font-size: 4rem;
+    font-weight: 700;
+    background: linear-gradient(135deg, #00d4ff, #ff6b35, #ffd700);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    margin-bottom: 0.5rem;
+    letter-spacing: -0.02em;
+}
+
+.tagline {
+    font-size: 1.2rem;
+    color: #8892b0;
+    font-weight: 300;
+}
+
+.nav-buttons {
+    display: flex;
+    gap: 1rem;
+    align-items: center;
+    flex-wrap: wrap;
+}
+
+.btn {
+    padding: 0.75rem 1.5rem;
+    border: none;
+    border-radius: 0.75rem;
+    font-size: 0.9rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    text-decoration: none;
+    display: inline-block;
+}
+
+/* ============================================================================
+   NAVIGATION BUTTONS - COMPLETE REDESIGN
+   ============================================================================ */
+
+/* Base button styles */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.75rem 1.5rem;
+    border: none;
+    border-radius: 0.5rem;
+    font-weight: 600;
+    font-size: 0.9rem;
+    text-decoration: none;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    white-space: nowrap;
+}
+
+/* Primary button (Dashboard) */
+.btn-primary {
+    background: #2563eb;
+    color: white;
+}
+
+.btn-primary:hover {
+    background: #1d4ed8;
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(37, 99, 235, 0.4);
+}
+
+/* Push notification button */
+.btn-push {
+    background: #10b981;
+    color: white;
+    position: relative;
+}
+
+.btn-push:hover {
+    background: #059669;
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(16, 185, 129, 0.4);
+}
+
+.btn-push.active {
+    background: #ef4444;
+}
+
+.btn-push.active:hover {
+    background: #dc2626;
+    box-shadow: 0 4px 12px rgba(239, 68, 68, 0.4);
+}
+
+.btn-push::after {
+    content: '';
+    position: absolute;
+    top: -2px;
+    right: -2px;
+    width: 8px;
+    height: 8px;
+    background: #fbbf24;
+    border-radius: 50%;
+    opacity: 0;
+    transition: opacity 0.3s ease;
+}
+
+.btn-push.active::after {
+    opacity: 1;
+    animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+    0% { transform: scale(1); opacity: 1; }
+    50% { transform: scale(1.2); opacity: 0.7; }
+    100% { transform: scale(1); opacity: 1; }
+}
+
+/* Logout button */
+.btn-logout {
+    background: #dc2626;
+    color: white;
+}
+
+.btn-logout:hover {
+    background: #b91c1c;
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(220, 38, 38, 0.4);
+}
+
+/* Mobile navigation container */
+.mobile-nav-buttons {
+    display: flex;
+    gap: 1rem;
+    align-items: center;
+    justify-content: flex-end;
+    margin: 1rem 0;
+    flex-wrap: wrap;
+    position: absolute;
+    top: 1rem;
+    right: 1rem;
+}
+
+/* Login button */
+.admin-login-btn {
+    background: #f59e0b;
+    color: white;
+}
+
+.admin-login-btn:hover {
+    background: #d97706;
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(245, 158, 11, 0.4);
+}
+
+/* Dashboard button */
+.dashboard-btn {
+    background: #2563eb;
+    color: white;
+}
+
+.dashboard-btn:hover {
+    background: #1d4ed8;
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(37, 99, 235, 0.4);
+}
+
+/* Logout button */
+.logout-btn {
+    background: #dc2626;
+    color: white;
+}
+
+.logout-btn:hover {
+    background: #b91c1c;
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(220, 38, 38, 0.4);
+}
+
+.dashboard-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 2rem;
+    margin-bottom: 2rem;
+}
+
+.welcome-card {
+    background: rgba(15, 23, 42, 0.8);
+    border: 1px solid #1e293b;
+    border-radius: 1rem;
+    padding: 2rem;
+    backdrop-filter: blur(20px);
+    margin-bottom: 2rem;
+    text-align: center;
+}
+
+.card {
+    background: rgba(15, 23, 42, 0.8);
+    border: 1px solid #1e293b;
+    border-radius: 1rem;
+    padding: 2rem;
+    backdrop-filter: blur(20px);
+    transition: all 0.2s ease;
+}
+
+.card:hover {
+    transform: translateY(-2px);
+    border-color: #00d4ff;
+    box-shadow: 0 10px 25px rgba(0, 212, 255, 0.1);
+}
+
+.card h3 {
+    color: #ffffff;
+    font-size: 1.3rem;
+    margin-bottom: 1rem;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.card p {
+    color: #8892b0;
+    line-height: 1.6;
+}
+
+.loading {
+    text-align: center;
+    padding: 2rem;
+    color: #8892b0;
+}
+
+.spinner {
+    border: 3px solid #1e293b;
+    border-top: 3px solid #00d4ff;
+    border-radius: 50%;
+    width: 40px;
+    height: 40px;
+    animation: spin 1s linear infinite;
+    margin: 0 auto 1rem;
+}
+
+@keyframes spin {
+    0% {
+        transform: rotate(0deg);
+    }
+
+    100% {
+        transform: rotate(360deg);
+    }
+}
+
+.user-info {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    color: #8892b0;
+    font-size: 0.9rem;
+}
+
+.user-avatar {
+    width: 30px;
+    height: 30px;
+    border-radius: 50%;
+    background: linear-gradient(135deg, #00d4ff, #0891b2);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: white;
+    font-weight: bold;
+    font-size: 0.8rem;
+}
+
+/* Modal Styles */
+.modal {
+    display: none;
+    position: fixed;
+    z-index: 2000;
+    left: 0;
+    top: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0, 0, 0, 0.8);
+    backdrop-filter: blur(10px);
+}
+
+.modal-content {
+    background: rgba(15, 23, 42, 0.95);
+    margin: 5% auto;
+    padding: 2rem;
+    border: 1px solid #1e293b;
+    border-radius: 1rem;
+    width: 90%;
+    max-width: 500px;
+    max-height: 80vh;
+    overflow-y: auto;
+    backdrop-filter: blur(20px);
+}
+
+.modal-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+}
+
+.modal-title {
+    color: #ffffff;
+    font-size: 1.5rem;
+    font-weight: 600;
+}
+
+.close {
+    color: #8892b0;
+    font-size: 2rem;
+    font-weight: bold;
+    cursor: pointer;
+}
+
+/* RFID Modal specific styles */
+#rfidModal .modal-content {
+    max-height: 85vh;
+    overflow-y: auto;
+}
+
+/* Smooth scrolling for modal content */
+.modal-content {
+    scroll-behavior: smooth;
+}
+
+/* Custom scrollbar for modal content */
+.modal-content::-webkit-scrollbar {
+    width: 8px;
+}
+
+.modal-content::-webkit-scrollbar-track {
+    background: rgba(30, 41, 59, 0.3);
+    border-radius: 4px;
+}
+
+.modal-content::-webkit-scrollbar-thumb {
+    background: rgba(100, 116, 139, 0.6);
+    border-radius: 4px;
+}
+
+.modal-content::-webkit-scrollbar-thumb:hover {
+    background: rgba(100, 116, 139, 0.8);
+}
+
+.close:hover {
+    color: #ffffff;
+}
+
+.form-group {
+    margin-bottom: 1.5rem;
+}
+
+.form-label {
+    display: block;
+    color: #e2e8f0;
+    font-weight: 500;
+    margin-bottom: 0.5rem;
+}
+
+.form-input {
+    width: 100%;
+    padding: 0.75rem;
+    background: #1e293b;
+    border: 2px solid #334155;
+    border-radius: 0.5rem;
+    color: #ffffff;
+    font-size: 1rem;
+    transition: border-color 0.2s ease;
+}
+
+.form-input:focus {
+    outline: none;
+    border-color: #00d4ff;
+}
+
+.form-input::placeholder {
+    color: #64748b;
+}
+
+.message {
+    padding: 1rem;
+    border-radius: 0.5rem;
+    margin-bottom: 1rem;
+    font-weight: 500;
+}
+
+.message.success {
+    background: rgba(34, 197, 94, 0.1);
+    color: #22c55e;
+    border: 1px solid rgba(34, 197, 94, 0.3);
+}
+
+.message.error {
+    background: rgba(239, 68, 68, 0.1);
+    color: #ef4444;
+    border: 1px solid rgba(239, 68, 68, 0.3);
+}
+
+.message.info {
+    background: rgba(59, 130, 246, 0.1);
+    color: #3b82f6;
+    border: 1px solid rgba(59, 130, 246, 0.3);
+}
+
+.player-selection {
+    display: grid;
+    gap: 0.5rem;
+    max-height: 200px;
+    overflow-y: auto;
+    background: #0f172a;
+    border-radius: 0.5rem;
+    padding: 1rem;
+}
+
+.player-option {
+    padding: 0.75rem;
+    background: #1e293b;
+    border: 2px solid #334155;
+    border-radius: 0.5rem;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.player-option:hover {
+    border-color: #00d4ff;
+    background: #334155;
+}
+
+.player-option.selected {
+    border-color: #00d4ff;
+    background: rgba(0, 212, 255, 0.1);
+}
+
+.player-info {
+    color: #e2e8f0;
+}
+
+.player-rfid {
+    color: #8892b0;
+    font-size: 0.9rem;
+    font-family: monospace;
+}
+
+.times-grid {
+    display: grid;
+    gap: 1rem;
+    max-height: 400px;
+    overflow-y: auto;
+}
+
+.time-card {
+    background: #1e293b;
+    border: 1px solid #334155;
+    border-radius: 0.5rem;
+    padding: 1rem;
+}
+
+.time-location {
+    color: #00d4ff;
+    font-weight: 600;
+    margin-bottom: 0.5rem;
+}
+
+.time-value {
+    color: #ffffff;
+    font-size: 1.2rem;
+    font-weight: bold;
+    font-family: monospace;
+}
+
+.time-date {
+    color: #8892b0;
+    font-size: 0.9rem;
+    margin-top: 0.5rem;
+}
+
+/* Times Section Styles */
+.times-section {
+    background: rgba(15, 23, 42, 0.8);
+    border: 1px solid #1e293b;
+    border-radius: 1rem;
+    padding: 2rem;
+    backdrop-filter: blur(20px);
+    margin-top: 2rem;
+}
+
+.times-header {
+    text-align: center;
+    margin-bottom: 2rem;
+}
+
+.times-header h2 {
+    color: #ffffff;
+    font-size: 2rem;
+    font-weight: 700;
+    margin-bottom: 0.5rem;
+}
+
+.times-header p {
+    color: #8892b0;
+    font-size: 1.1rem;
+}
+
+.times-loading {
+    text-align: center;
+    padding: 3rem;
+    color: #8892b0;
+}
+
+.times-not-linked {
+    text-align: center;
+    padding: 3rem 2rem;
+}
+
+.not-linked-content {
+    max-width: 600px;
+    margin: 0 auto;
+}
+
+.not-linked-icon {
+    font-size: 4rem;
+    margin-bottom: 1rem;
+}
+
+.times-not-linked h3 {
+    color: #ffffff;
+    font-size: 1.5rem;
+    font-weight: 600;
+    margin-bottom: 1rem;
+}
+
+.times-not-linked p {
+    color: #8892b0;
+    font-size: 1.1rem;
+    margin-bottom: 2rem;
+    line-height: 1.6;
+}
+
+.link-info {
+    background: rgba(0, 212, 255, 0.1);
+    border: 1px solid rgba(0, 212, 255, 0.3);
+    border-radius: 0.75rem;
+    padding: 1.5rem;
+    margin-top: 2rem;
+    text-align: left;
+}
+
+.link-info h4 {
+    color: #00d4ff;
+    font-size: 1.1rem;
+    font-weight: 600;
+    margin-bottom: 1rem;
+}
+
+.link-info ol {
+    color: #cbd5e1;
+    padding-left: 1.5rem;
+}
+
+.link-info li {
+    margin-bottom: 0.5rem;
+    line-height: 1.5;
+}
+
+.times-stats {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 1.5rem;
+    margin-bottom: 2rem;
+}
+
+.stat-card {
+    background: rgba(0, 212, 255, 0.1);
+    border: 1px solid rgba(0, 212, 255, 0.3);
+    border-radius: 0.75rem;
+    padding: 1.5rem;
+    text-align: center;
+    transition: all 0.2s ease;
+}
+
+.stat-card:hover {
+    transform: translateY(-2px);
+    border-color: #00d4ff;
+    box-shadow: 0 10px 25px rgba(0, 212, 255, 0.1);
+}
+
+.stat-number {
+    color: #00d4ff;
+    font-size: 2rem;
+    font-weight: 700;
+    font-family: monospace;
+    margin-bottom: 0.5rem;
+}
+
+.stat-label {
+    color: #8892b0;
+    font-size: 0.9rem;
+    font-weight: 500;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.times-content {
+    margin-top: 2rem;
+}
+
+.times-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+    gap: 1.5rem;
+}
+
+.user-time-card {
+    background: #1e293b;
+    border: 1px solid #334155;
+    border-radius: 0.75rem;
+    padding: 1.5rem;
+    transition: all 0.3s ease;
+    position: relative;
+    overflow: hidden;
+    cursor: pointer;
+}
+
+.user-time-card:hover {
+    transform: translateY(-2px);
+    border-color: #00d4ff;
+    box-shadow: 0 10px 25px rgba(0, 212, 255, 0.1);
+}
+
+.user-time-card.expanded {
+    transform: none;
+    border-color: #00d4ff;
+    box-shadow: 0 10px 25px rgba(0, 212, 255, 0.2);
+}
+
+.user-time-card::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    height: 3px;
+    background: linear-gradient(90deg, #00d4ff, #0891b2);
+}
+
+.time-location-name {
+    color: #00d4ff;
+    font-weight: 600;
+    font-size: 1.1rem;
+    margin-bottom: 0.5rem;
+}
+
+.time-value-large {
+    color: #ffffff;
+    font-size: 2rem;
+    font-weight: bold;
+    font-family: monospace;
+    margin-bottom: 0.5rem;
+}
+
+.time-date-info {
+    color: #8892b0;
+    font-size: 0.9rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.time-rank {
+    background: rgba(255, 107, 53, 0.1);
+    color: #ff6b35;
+    padding: 0.25rem 0.5rem;
+    border-radius: 0.375rem;
+    font-size: 0.8rem;
+    font-weight: 600;
+}
+
+.card-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start;
+    margin-bottom: 1rem;
+}
+
+.expand-indicator {
+    color: #8892b0;
+    font-size: 1.2rem;
+    transition: transform 0.3s ease;
+    margin-left: 0.5rem;
+}
+
+.user-time-card.expanded .expand-indicator {
+    transform: rotate(180deg);
+}
+
+.card-main-content {
+    margin-bottom: 1rem;
+}
+
+.expanded-content {
+    max-height: 0;
+    overflow: hidden;
+    transition: max-height 0.3s ease, opacity 0.3s ease;
+    opacity: 0;
+}
+
+.user-time-card.expanded .expanded-content {
+    max-height: 1000px;
+    opacity: 1;
+}
+
+.all-runs-title {
+    color: #00d4ff;
+    font-size: 1rem;
+    font-weight: 600;
+    margin-bottom: 1rem;
+    padding-top: 1rem;
+    border-top: 1px solid #334155;
+}
+
+.run-item {
+    background: rgba(0, 212, 255, 0.05);
+    border: 1px solid rgba(0, 212, 255, 0.1);
+    border-radius: 0.5rem;
+    padding: 1rem;
+    margin-bottom: 0.75rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    transition: all 0.2s ease;
+}
+
+.run-item:hover {
+    background: rgba(0, 212, 255, 0.1);
+    border-color: rgba(0, 212, 255, 0.3);
+}
+
+.run-item:last-child {
+    margin-bottom: 0;
+}
+
+.run-time {
+    color: #ffffff;
+    font-size: 1.1rem;
+    font-weight: 600;
+    font-family: monospace;
+}
+
+.run-details {
+    text-align: right;
+    color: #8892b0;
+    font-size: 0.85rem;
+}
+
+.run-rank-badge {
+    background: #00d4ff;
+    color: #0a0a0f;
+    padding: 0.2rem 0.5rem;
+    border-radius: 0.3rem;
+    font-size: 0.75rem;
+    font-weight: 700;
+    margin-left: 0.5rem;
+}
+
+.run-rank-badge.best {
+    background: #22c55e;
+}
+
+.run-rank-badge.second {
+    background: #f59e0b;
+}
+
+.run-rank-badge.third {
+    background: #ef4444;
+}
+
+/* Mobile First Responsive Design */
+@media (max-width: 768px) {
+    .main-container {
+        padding: 1rem;
+        max-width: 100%;
+    }
+
+    .sticky-header {
+        flex-direction: column;
+        gap: 1rem;
+        padding: 1rem;
+        margin-bottom: 1rem;
+    }
+
+    .language-selector {
+        order: -1;
+        text-align: center;
+        width: 100%;
+    }
+
+    .main-title {
+        font-size: 2.5rem;
+        margin-bottom: 0.5rem;
+    }
+
+    .tagline {
+        font-size: 1rem;
+    }
+
+    .nav-buttons {
+        flex-direction: column;
+        gap: 0.5rem;
+        width: 100%;
+    }
+
+    .user-info {
+        order: -1;
+        margin-bottom: 0.5rem;
+        padding-bottom: 0.5rem;
+        border-bottom: 1px solid #334155;
+        width: 100%;
+        justify-content: center;
+    }
+
+    .btn {
+        width: 100%;
+        padding: 1rem;
+        font-size: 1rem;
+        text-align: center;
+    }
+
+    .dashboard-grid {
+        grid-template-columns: 1fr;
+        gap: 1rem;
+        margin-bottom: 1.5rem;
+    }
+
+    .card {
+        padding: 1.5rem;
+    }
+
+    .card h3 {
+        font-size: 1.1rem;
+    }
+
+    .welcome-card {
+        padding: 1.5rem;
+        margin-bottom: 1.5rem;
+    }
+
+    .times-section {
+        padding: 1.5rem;
+        margin-top: 1.5rem;
+    }
+
+    .times-header h2 {
+        font-size: 1.5rem;
+    }
+
+    .times-header p {
+        font-size: 1rem;
+    }
+
+    .times-stats {
+        grid-template-columns: repeat(2, 1fr);
+        gap: 1rem;
+        margin-bottom: 1.5rem;
+    }
+
+    .stat-card {
+        padding: 1rem;
+    }
+
+    .stat-number {
+        font-size: 1.5rem;
+    }
+
+    .stat-label {
+        font-size: 0.8rem;
+    }
+
+    .times-grid {
+        grid-template-columns: 1fr;
+        gap: 1rem;
+    }
+
+    .user-time-card {
+        padding: 1rem;
+    }
+
+    .time-value-large {
+        font-size: 1.5rem;
+    }
+
+    .modal-content {
+        margin: 1% auto;
+        width: 95%;
+        padding: 1rem;
+        max-height: 90vh;
+        overflow-y: auto;
+    }
+
+    .modal-title {
+        font-size: 1.2rem;
+    }
+
+    .form-input {
+        padding: 1rem;
+        font-size: 1rem;
+    }
+
+    .player-selection {
+        max-height: 150px;
+    }
+
+    .player-option {
+        padding: 1rem;
+    }
+
+    .run-item {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 0.5rem;
+    }
+
+    .run-details {
+        text-align: left;
+    }
+}
+
+/* Extra small devices (phones in portrait) */
+@media (max-width: 480px) {
+    .main-container {
+        padding: 0.5rem;
+    }
+
+    .sticky-header {
+        padding: 0.75rem;
+        margin-bottom: 0.75rem;
+    }
+
+    .main-title {
+        font-size: 2rem;
+    }
+
+    .tagline {
+        font-size: 0.9rem;
+    }
+
+    .nav-buttons {
+        top: 0;
+        right: 0.5rem;
+        left: 0.5rem;
+        padding: 0.75rem;
+        margin-bottom: 0.75rem;
+    }
+
+    .card {
+        padding: 1rem;
+    }
+
+    .times-section {
+        padding: 1rem;
+    }
+
+    .times-stats {
+        grid-template-columns: 1fr;
+        gap: 0.75rem;
+    }
+
+    .stat-card {
+        padding: 0.75rem;
+    }
+
+    .stat-number {
+        font-size: 1.25rem;
+    }
+
+    .modal-content {
+        margin: 0.5% auto;
+        width: 98%;
+        padding: 0.75rem;
+    }
+
+    .times-header h2 {
+        font-size: 1.25rem;
+    }
+
+    .times-header p {
+        font-size: 0.9rem;
+    }
+}
+
+/* Landscape orientation on mobile */
+@media (max-width: 768px) and (orientation: landscape) {
+    .sticky-header {
+        flex-direction: row;
+        justify-content: space-between;
+    }
+
+    .nav-buttons {
+        flex-direction: row;
+        flex-wrap: wrap;
+        justify-content: flex-end;
+    }
+
+    .user-info {
+        order: 0;
+        margin-bottom: 0;
+        padding-bottom: 0;
+        border-bottom: none;
+        width: auto;
+    }
+
+    .btn {
+        width: auto;
+        flex: 1;
+        min-width: 120px;
+    }
+
+    .main-title {
+        font-size: 2rem;
+    }
+
+    .times-stats {
+        grid-template-columns: repeat(4, 1fr);
+    }
+}
+
+/* Touch-friendly improvements for mobile */
+@media (max-width: 768px) {
+    .btn {
+        min-height: 44px;
+        /* Apple's recommended minimum touch target */
+        touch-action: manipulation;
+        /* Prevents double-tap zoom */
+    }
+
+    .card {
+        touch-action: manipulation;
+    }
+
+    .user-time-card {
+        touch-action: manipulation;
+    }
+
+    .player-option {
+        min-height: 44px;
+        touch-action: manipulation;
+    }
+
+    .close {
+        min-width: 44px;
+        min-height: 44px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+    }
+
+    /* Improve scrolling on mobile */
+    .times-grid {
+        -webkit-overflow-scrolling: touch;
+    }
+
+    .player-selection {
+        -webkit-overflow-scrolling: touch;
+    }
+
+    /* Better spacing for mobile */
+    .header-section {
+        margin-bottom: 2rem;
+        margin-top: 1rem;
+    }
+
+    /* Improve modal usability on mobile */
+    .modal {
+        padding: 1rem;
+    }
+
+    .modal-content {
+        border-radius: 0.75rem;
+    }
+
+    /* Better form inputs on mobile */
+    .form-input {
+        -webkit-appearance: none;
+        appearance: none;
+        border-radius: 0.5rem;
+    }
+
+    /* Improve video container on mobile */
+    #cameraContainer video {
+        max-width: 100%;
+        height: auto;
+        border-radius: 0.5rem;
+    }
+}
+
+/* Footer Styles */
+.footer {
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    border-top: 1px solid #2a2a3e;
+    margin-top: 3rem;
+    padding: 2rem 0;
+}
+
+.footer-content {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 0 2rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.footer-links {
+    display: flex;
+    gap: 2rem;
+    align-items: center;
+}
+
+.footer-link {
+    color: #8892b0;
+    text-decoration: none;
+    font-size: 0.9rem;
+    transition: color 0.3s ease;
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-family: inherit;
+}
+
+.footer-link:hover {
+    color: #00d4ff;
+}
+
+.cookie-settings-btn {
+    background: none !important;
+    border: none !important;
+    padding: 0 !important;
+    font-size: 0.9rem !important;
+}
+
+.footer-text {
+    color: #6b7280;
+    font-size: 0.85rem;
+}
+
+.footer-text p {
+    margin: 0;
+}
+
+@media (max-width: 768px) {
+    .footer-content {
+        flex-direction: column;
+        text-align: center;
+        gap: 1.5rem;
+    }
+
+    .footer-links {
+        flex-wrap: wrap;
+        justify-content: center;
+        gap: 1.5rem;
+    }
+}
+
+/* ==================== ACHIEVEMENT STYLES ==================== */
+
+.achievements-section {
+    margin-bottom: 3rem;
+}
+
+.achievements-header {
+    text-align: center;
+    margin-bottom: 2rem;
+}
+
+.achievements-header h2 {
+    font-size: 2.5rem;
+    font-weight: 700;
+    background: linear-gradient(135deg, #ffd700, #ff6b35);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    margin-bottom: 0.5rem;
+}
+
+.achievements-header p {
+    color: #8892b0;
+    font-size: 1.1rem;
+}
+
+/* Achievement Stats */
+.achievement-stats {
+    display: flex;
+    gap: 1rem;
+    margin-bottom: 2rem;
+    flex-wrap: wrap;
+    justify-content: center;
+}
+
+.achievement-stat {
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    border: 1px solid #2a2a3e;
+    border-radius: 1rem;
+    padding: 1.5rem;
+    text-align: center;
+    min-width: 150px;
+    flex: 1;
+    max-width: 200px;
+}
+
+.achievement-stat .stat-number {
+    font-size: 2rem;
+    font-weight: 700;
+    color: #00d4ff;
+    margin-bottom: 0.5rem;
+}
+
+.achievement-stat .stat-label {
+    color: #8892b0;
+    font-size: 0.9rem;
+    font-weight: 500;
+}
+
+/* Achievement Categories */
+.achievement-categories {
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    border: 1px solid #2a2a3e;
+    border-radius: 1rem;
+    padding: 2rem;
+}
+
+.category-tabs {
+    display: flex;
+    gap: 0.5rem;
+    margin-bottom: 2rem;
+    flex-wrap: wrap;
+    justify-content: center;
+}
+
+.category-tab {
+    background: transparent;
+    border: 1px solid #2a2a3e;
+    color: #8892b0;
+    padding: 0.75rem 1.5rem;
+    border-radius: 0.5rem;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-family: inherit;
+    font-size: 0.9rem;
+    font-weight: 500;
+}
+
+.category-tab:hover {
+    background: #2a2a3e;
+    color: #ffffff;
+}
+
+.category-tab.active {
+    background: linear-gradient(135deg, #00d4ff, #ff6b35);
+    border-color: transparent;
+    color: #ffffff;
+}
+
+/* Achievements Grid */
+.achievements-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+    gap: 1.5rem;
+}
+
+.achievement-card {
+    background: linear-gradient(135deg, #0f1419 0%, #1a1a2e 100%);
+    border: 1px solid #2a2a3e;
+    border-radius: 1rem;
+    padding: 1.5rem;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    position: relative;
+    overflow: hidden;
+}
+
+.achievement-card:hover {
+    transform: translateY(-2px);
+    border-color: #00d4ff;
+    box-shadow: 0 8px 25px rgba(0, 212, 255, 0.1);
+}
+
+.achievement-card.completed {
+    border-color: #10b981;
+    background: linear-gradient(135deg, #064e3b 0%, #1a1a2e 100%);
+}
+
+.achievement-card.completed:hover {
+    border-color: #10b981;
+    box-shadow: 0 8px 25px rgba(16, 185, 129, 0.1);
+}
+
+.achievement-card.incomplete {
+    opacity: 0.7;
+}
+
+.achievement-card.incomplete:hover {
+    opacity: 1;
+}
+
+.achievement-icon {
+    font-size: 2.5rem;
+    margin-bottom: 1rem;
+    text-align: center;
+}
+
+.achievement-content {
+    flex: 1;
+}
+
+.achievement-name {
+    font-size: 1.2rem;
+    font-weight: 600;
+    color: #ffffff;
+    margin-bottom: 0.5rem;
+}
+
+.achievement-description {
+    color: #8892b0;
+    font-size: 0.9rem;
+    line-height: 1.4;
+    margin-bottom: 1rem;
+}
+
+.achievement-meta {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+}
+
+.achievement-points {
+    color: #ffd700;
+    font-weight: 600;
+    font-size: 0.9rem;
+}
+
+.achievement-progress {
+    color: #00d4ff;
+    font-size: 0.8rem;
+    font-weight: 500;
+}
+
+.achievement-status {
+    position: absolute;
+    top: 1rem;
+    right: 1rem;
+    font-size: 1.2rem;
+}
+
+/* Achievement Loading States */
+.achievements-loading {
+    text-align: center;
+    padding: 3rem;
+    color: #8892b0;
+}
+
+.achievements-not-available {
+    text-align: center;
+    padding: 3rem;
+}
+
+.not-available-content {
+    max-width: 400px;
+    margin: 0 auto;
+}
+
+.not-available-icon {
+    font-size: 4rem;
+    margin-bottom: 1rem;
+}
+
+.not-available-content h3 {
+    color: #ffffff;
+    margin-bottom: 1rem;
+    font-size: 1.5rem;
+}
+
+.not-available-content p {
+    color: #8892b0;
+    margin-bottom: 2rem;
+    line-height: 1.5;
+}
+
+/* No Achievements State */
+.no-achievements {
+    text-align: center;
+    padding: 3rem;
+    color: #8892b0;
+    grid-column: 1 / -1;
+}
+
+.no-achievements-icon {
+    font-size: 3rem;
+    margin-bottom: 1rem;
+}
+
+.no-achievements h3 {
+    color: #ffffff;
+    margin-bottom: 0.5rem;
+    font-size: 1.3rem;
+}
+
+/* Achievement Notifications */
+.achievement-notification {
+    position: fixed;
+    top: 2rem;
+    right: 2rem;
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    border: 1px solid #10b981;
+    border-radius: 1rem;
+    padding: 1.5rem;
+    box-shadow: 0 8px 25px rgba(16, 185, 129, 0.2);
+    z-index: 1000;
+    max-width: 350px;
+    animation: slideInRight 0.3s ease;
+}
+
+@keyframes slideInRight {
+    from {
+        transform: translateX(100%);
+        opacity: 0;
+    }
+
+    to {
+        transform: translateX(0);
+        opacity: 1;
+    }
+}
+
+.notification-content {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+}
+
+.notification-icon {
+    font-size: 2rem;
+}
+
+.notification-text h4 {
+    color: #ffffff;
+    margin-bottom: 0.25rem;
+    font-size: 1.1rem;
+}
+
+.notification-text p {
+    color: #8892b0;
+    font-size: 0.9rem;
+    margin: 0;
+}
+
+.notification-close {
+    background: none;
+    border: none;
+    color: #8892b0;
+    font-size: 1.5rem;
+    cursor: pointer;
+    padding: 0;
+    margin-left: auto;
+    transition: color 0.3s ease;
+}
+
+.notification-close:hover {
+    color: #ffffff;
+}
+
+/* Mobile Responsiveness for Achievements */
+@media (max-width: 768px) {
+    .achievements-header h2 {
+        font-size: 2rem;
+    }
+
+    .achievement-stats {
+        flex-direction: column;
+        align-items: center;
+    }
+
+    .achievement-stat {
+        width: 100%;
+        max-width: 250px;
+    }
+
+    .category-tabs {
+        flex-direction: column;
+        align-items: center;
+    }
+
+    .category-tab {
+        width: 100%;
+        max-width: 200px;
+        text-align: center;
+    }
+
+    .achievements-grid {
+        grid-template-columns: 1fr;
+        gap: 1rem;
+    }
+
+    .achievement-notification {
+        top: 1rem;
+        right: 1rem;
+        left: 1rem;
+        max-width: none;
+    }
+}
+
+
+.last-location-info small {
+    color: #b3e5fc;
+    font-size: 0.85rem;
+}
+
+/* Settings Modal Styles */
+.settings-content {
+    padding: 1.5rem 0;
+}
+
+.setting-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 1.5rem;
+    background: #1e293b;
+    border-radius: 0.75rem;
+    margin-bottom: 1rem;
+    border: 1px solid #334155;
+}
+
+.setting-info h3 {
+    color: #ffffff;
+    font-size: 1.1rem;
+    font-weight: 600;
+    margin-bottom: 0.5rem;
+}
+
+.setting-info p {
+    color: #8892b0;
+    font-size: 0.9rem;
+    line-height: 1.4;
+}
+
+.setting-control {
+    margin-left: 1rem;
+}
+
+/* Toggle Switch Styles */
+.toggle-switch {
+    position: relative;
+    display: inline-block;
+    width: 60px;
+    height: 34px;
+}
+
+.toggle-switch input {
+    opacity: 0;
+    width: 0;
+    height: 0;
+}
+
+.toggle-slider {
+    position: absolute;
+    cursor: pointer;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: #334155;
+    transition: 0.3s;
+    border-radius: 34px;
+}
+
+.toggle-slider:before {
+    position: absolute;
+    content: "";
+    height: 26px;
+    width: 26px;
+    left: 4px;
+    bottom: 4px;
+    background-color: white;
+    transition: 0.3s;
+    border-radius: 50%;
+}
+
+input:checked+.toggle-slider {
+    background-color: #00d4ff;
+}
+
+input:checked+.toggle-slider:before {
+    transform: translateX(26px);
+}
+
+.setting-description {
+    margin-top: 1rem;
+}
+
+.settings-actions {
+    display: flex;
+    gap: 1rem;
+    margin-top: 2rem;
+    justify-content: flex-end;
+}
+
+.settings-actions .btn {
+    min-width: 120px;
+}
+
+/* Analytics and Statistics Styles */
+.analytics-section, .statistics-section {
+    margin: 2rem 0;
+    padding: 1.5rem;
+    background: linear-gradient(135deg, #2c3e50 0%, #34495e 100%);
+    border-radius: 10px;
+    border: 1px solid #34495e;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.3);
+}
+
+.section-header {
+    text-align: center;
+    margin-bottom: 2rem;
+}
+
+.section-header h2 {
+    color: #ecf0f1;
+    margin-bottom: 0.5rem;
+    font-size: 2rem;
+    text-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+}
+
+.section-header p {
+    color: #bdc3c7;
+    font-size: 1.1rem;
+}
+
+.analytics-grid, .statistics-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 1.5rem;
+    margin-top: 1.5rem;
+}
+
+.analytics-card, .statistics-card {
+    background: linear-gradient(135deg, #34495e 0%, #2c3e50 100%);
+    padding: 1.5rem;
+    border-radius: 8px;
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
+    border: 1px solid #34495e;
+    transition: transform 0.2s ease, box-shadow 0.2s ease;
+}
+
+.analytics-card:hover, .statistics-card:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 6px 12px rgba(0, 0, 0, 0.4);
+}
+
+.analytics-card h3, .statistics-card h3 {
+    color: #ecf0f1;
+    margin-bottom: 1rem;
+    font-size: 1.2rem;
+    border-bottom: 2px solid #3498db;
+    padding-bottom: 0.5rem;
+    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
+}
+
+/* Mini Stats in Cards */
+.analytics-stats, .statistics-stats {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+    gap: 1rem;
+    margin-bottom: 1rem;
+}
+
+.mini-stat {
+    text-align: center;
+    padding: 0.5rem;
+    background: rgba(52, 73, 94, 0.6);
+    border-radius: 5px;
+    border: 1px solid #34495e;
+}
+
+.mini-stat-number {
+    font-size: 1.2rem;
+    font-weight: bold;
+    color: #ecf0f1;
+    margin-bottom: 0.25rem;
+    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
+}
+
+.mini-stat-label {
+    font-size: 0.8rem;
+    color: #bdc3c7;
+}
+
+/* Trend Stats */
+.trend-stats, .activity-stats, .monthly-stats, .consistency-stats, .progress-stats {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+}
+
+.trend-item, .activity-item, .monthly-item, .consistency-item, .progress-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 0.5rem;
+    background: rgba(52, 73, 94, 0.6);
+    border-radius: 5px;
+    border: 1px solid #34495e;
+    margin-bottom: 0.5rem;
+}
+
+.trend-label, .activity-label, .monthly-label, .consistency-label, .progress-label {
+    font-weight: 500;
+    color: #bdc3c7;
+}
+
+.trend-value, .activity-value, .monthly-value, .consistency-value, .progress-value {
+    font-weight: bold;
+    color: #ecf0f1;
+    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
+}
+
+/* Personal Records */
+.personal-records {
+    max-height: 200px;
+    overflow-y: auto;
+}
+
+.record-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 0.5rem;
+    margin-bottom: 0.5rem;
+    background: rgba(52, 73, 94, 0.6);
+    border-radius: 5px;
+    border-left: 4px solid #3498db;
+    border: 1px solid #34495e;
+}
+
+.record-rank {
+    font-weight: bold;
+    color: #e74c3c;
+    font-size: 1.1rem;
+    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
+}
+
+.record-time {
+    font-weight: bold;
+    color: #ecf0f1;
+    font-family: 'Courier New', monospace;
+    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
+}
+
+.record-location {
+    color: #bdc3c7;
+    font-size: 0.9rem;
+}
+
+/* Location Performance */
+.location-stats {
+    max-height: 200px;
+    overflow-y: auto;
+}
+
+.location-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 0.5rem;
+    margin-bottom: 0.5rem;
+    background: rgba(52, 73, 94, 0.6);
+    border-radius: 5px;
+    border: 1px solid #34495e;
+}
+
+.location-name {
+    font-weight: 500;
+    color: #ecf0f1;
+}
+
+.location-best {
+    font-weight: bold;
+    color: #27ae60;
+    font-family: 'Courier New', monospace;
+    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
+}
+
+.location-runs {
+    color: #bdc3c7;
+    font-size: 0.9rem;
+}
+
+/* Ranking Stats */
+.ranking-stats {
+    max-height: 200px;
+    overflow-y: auto;
+}
+
+.ranking-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 0.5rem;
+    margin-bottom: 0.5rem;
+    background: rgba(52, 73, 94, 0.6);
+    border-radius: 5px;
+    border: 1px solid #34495e;
+}
+
+.ranking-category {
+    font-weight: 500;
+    color: #ecf0f1;
+}
+
+.ranking-position {
+    font-weight: bold;
+    color: #e74c3c;
+    font-size: 1.1rem;
+    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
+}
+
+.ranking-total {
+    color: #bdc3c7;
+    font-size: 0.9rem;
+}
+
+/* Responsive Settings */
+@media (max-width: 768px) {
+    .setting-item {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 1rem;
+    }
+
+    .setting-control {
+        margin-left: 0;
+        align-self: flex-end;
+    }
+
+    .settings-actions {
+        flex-direction: column;
+    }
+
+    .settings-actions .btn {
+        width: 100%;
+    }
+}
+
+/* PWA Button Styles */
+.btn-pwa {
+    background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+    color: white;
+    border: none;
+    padding: 0.75rem 1.5rem;
+    border-radius: 0.5rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    box-shadow: 0 4px 15px rgba(240, 147, 251, 0.3);
+    margin-left: 0.5rem;
+}
+
+.btn-pwa:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 6px 20px rgba(240, 147, 251, 0.4);
+}
+
+.btn-pwa:active {
+    transform: translateY(0);
+}
+
+/* iOS PWA Hint Styles */
+#ios-pwa-hint {
+    animation: slideDown 0.3s ease-out;
+}
+
+@keyframes slideDown {
+    from {
+        opacity: 0;
+        transform: translateX(-50%) translateY(-20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateX(-50%) translateY(0);
+    }
+}
\ No newline at end of file
diff --git a/public/css/generator.css b/public/css/generator.css
new file mode 100644
index 0000000..0dd3471
--- /dev/null
+++ b/public/css/generator.css
@@ -0,0 +1,500 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+html,
+body {
+    height: 100%;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: 'Inter', sans-serif;
+    background: #0a0a0f;
+    color: #ffffff;
+    min-height: 100vh;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: flex-start;
+    padding: 20px;
+    background-image:
+        radial-gradient(circle at 20% 80%, #1a1a2e 0%, transparent 50%),
+        radial-gradient(circle at 80% 20%, #16213e 0%, transparent 50%),
+        radial-gradient(circle at 40% 40%, #0f3460 0%, transparent 50%);
+}
+
+.container {
+    background: rgba(26, 26, 46, 0.95);
+    backdrop-filter: blur(10px);
+    border-radius: 20px;
+    box-shadow: 0 20px 40px rgba(0, 0, 0, 0.3);
+    padding: 40px;
+    max-width: 700px;
+    width: 100%;
+    position: relative;
+    overflow: visible;
+    margin-bottom: 20px;
+    display: flex;
+    flex-direction: column;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.container::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    height: 4px;
+    background: linear-gradient(90deg, #667eea, #764ba2, #f093fb, #f5576c);
+    background-size: 300% 100%;
+    animation: gradientShift 3s ease infinite;
+}
+
+@keyframes gradientShift {
+    0% {
+        background-position: 0% 50%;
+    }
+
+    50% {
+        background-position: 100% 50%;
+    }
+
+    100% {
+        background-position: 0% 50%;
+    }
+}
+
+h1 {
+    text-align: center;
+    color: #ffffff;
+    margin-bottom: 30px;
+    font-size: 2.2em;
+    font-weight: 300;
+    letter-spacing: -1px;
+}
+
+.form-group {
+    margin-bottom: 25px;
+    position: relative;
+}
+
+label {
+    display: block;
+    margin-bottom: 8px;
+    color: #555;
+    font-weight: 500;
+    font-size: 0.95em;
+}
+
+input,
+textarea {
+    width: 100%;
+    padding: 15px 20px;
+    border: 2px solid #e0e0e0;
+    border-radius: 12px;
+    font-size: 1em;
+    transition: all 0.3s ease;
+    background: #fafafa;
+    font-family: inherit;
+}
+
+textarea {
+    resize: vertical;
+    min-height: 80px;
+}
+
+input:focus,
+textarea:focus {
+    outline: none;
+    border-color: #667eea;
+    background: white;
+    box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+    transform: translateY(-2px);
+}
+
+input:hover,
+textarea:hover {
+    border-color: #ccc;
+}
+
+.db-config {
+    background: linear-gradient(135deg, #f8f9ff 0%, #e8f2ff 100%);
+    border: 2px solid #e3f2fd;
+    border-radius: 12px;
+    padding: 20px;
+    margin-bottom: 25px;
+    opacity: 0;
+    transform: translateY(-20px);
+    transition: all 0.4s ease;
+    max-height: 0;
+    overflow: hidden;
+}
+
+.db-config.show {
+    opacity: 1;
+    transform: translateY(0);
+    max-height: 1000px;
+}
+
+.db-config h3 {
+    color: #1565c0;
+    margin-bottom: 15px;
+    font-size: 1.1em;
+}
+
+.tier-notice {
+    background: linear-gradient(135deg, #fff3e0 0%, #ffe0b2 100%);
+    border: 2px solid #ffcc02;
+    border-radius: 8px;
+    padding: 12px;
+    margin-top: 10px;
+    font-size: 0.9em;
+    color: #f57c00;
+    text-align: center;
+}
+
+.generate-btn {
+    width: 100%;
+    padding: 18px;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border: none;
+    border-radius: 12px;
+    font-size: 1.1em;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    margin-top: 10px;
+    position: relative;
+    overflow: hidden;
+}
+
+.generate-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 10px 25px rgba(102, 126, 234, 0.3);
+}
+
+.generate-btn:active {
+    transform: translateY(0);
+}
+
+.result-section {
+    margin-top: 30px;
+    opacity: 0;
+    transform: translateY(20px);
+    transition: all 0.4s ease;
+}
+
+.result-section.show {
+    opacity: 1;
+    transform: translateY(0);
+}
+
+.license-output {
+    background: linear-gradient(135deg, #f8f9ff 0%, #e8f2ff 100%);
+    border: 2px solid #e3f2fd;
+    border-radius: 12px;
+    padding: 20px;
+    font-family: 'Courier New', monospace;
+    font-size: 0.9em;
+    word-break: break-all;
+    color: #1565c0;
+    position: relative;
+}
+
+.license-label {
+    font-family: 'Segoe UI', sans-serif;
+    font-size: 0.85em;
+    color: #666;
+    margin-bottom: 8px;
+    font-weight: 500;
+}
+
+.copy-btn {
+    width: 100%;
+    padding: 12px;
+    background: #4caf50;
+    color: white;
+    border: none;
+    border-radius: 8px;
+    font-size: 0.95em;
+    font-weight: 500;
+    cursor: pointer;
+    margin-top: 15px;
+    transition: all 0.3s ease;
+}
+
+.copy-btn:hover {
+    background: #45a049;
+    transform: translateY(-1px);
+}
+
+.copy-btn.copied {
+    background: #2196f3;
+    animation: pulse 0.6s;
+}
+
+@keyframes pulse {
+    0% {
+        transform: scale(1);
+    }
+
+    50% {
+        transform: scale(1.05);
+    }
+
+    100% {
+        transform: scale(1);
+    }
+}
+
+.success {
+    background: #e8f5e8;
+    color: #2e7d32;
+    padding: 15px;
+    border-radius: 8px;
+    margin-top: 15px;
+    border-left: 4px solid #4caf50;
+    font-size: 0.9em;
+    opacity: 0;
+    transform: translateY(-10px);
+    transition: all 0.3s ease;
+}
+
+.success.show {
+    opacity: 1;
+    transform: translateY(0);
+}
+
+.error {
+    background: #ffebee;
+    color: #c62828;
+    padding: 15px;
+    border-radius: 8px;
+    margin-top: 15px;
+    border-left: 4px solid #f44336;
+    font-size: 0.9em;
+    opacity: 0;
+    transform: translateY(-10px);
+    transition: all 0.3s ease;
+}
+
+.error.show {
+    opacity: 1;
+    transform: translateY(0);
+}
+
+.info-text {
+    text-align: center;
+    color: #666;
+    font-size: 0.85em;
+    margin-top: 20px;
+    line-height: 1.5;
+}
+
+@media (max-width: 480px) {
+    .container {
+        padding: 30px 20px;
+        margin: 10px;
+    }
+
+    h1 {
+        font-size: 1.8em;
+    }
+}
+
+.loading {
+    display: inline-block;
+    width: 20px;
+    height: 20px;
+    border: 3px solid rgba(255, 255, 255, .3);
+    border-radius: 50%;
+    border-top-color: #fff;
+    animation: spin 1s ease-in-out infinite;
+    margin-right: 10px;
+}
+
+@keyframes spin {
+    to {
+        transform: rotate(360deg);
+    }
+}
+
+/* Standortsuche Styles */
+.coordinates-display {
+    animation: slideDown 0.4s ease;
+}
+
+.map-container {
+    animation: slideDown 0.4s ease;
+}
+
+@keyframes slideDown {
+    from {
+        opacity: 0;
+        transform: translateY(-10px);
+    }
+
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+#mapFrame iframe {
+    border-radius: 10px;
+}
+
+.coordinates-display h4 {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.coordinates-display strong {
+    color: #2e7d32;
+}
+
+/* Verbesserte Standortsuche Layouts */
+.location-search-container {
+    display: flex;
+    gap: 10px;
+    align-items: stretch;
+}
+
+.location-search-container input {
+    flex: 1;
+    min-width: 0;
+}
+
+.location-search-container button {
+    white-space: nowrap;
+    min-width: 120px;
+}
+
+/* Responsive Design für Standortsuche */
+@media (max-width: 600px) {
+    .location-search-container {
+        flex-direction: column;
+        gap: 15px;
+    }
+
+    .location-search-container button {
+        min-width: auto;
+        width: 100%;
+    }
+
+    .coordinates-display .flex-container {
+        flex-direction: column;
+        gap: 10px;
+    }
+}
+
+/* Interaktive Karte Styles */
+#interactiveMap {
+    position: relative;
+}
+
+#map {
+    border-radius: 10px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+}
+
+.leaflet-container {
+    border-radius: 10px;
+}
+
+.leaflet-control-zoom {
+    border: none;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.2);
+}
+
+.leaflet-control-zoom a {
+    background: white;
+    color: #333;
+    border: 1px solid #ddd;
+}
+
+.leaflet-control-zoom a:hover {
+    background: #f8f9fa;
+}
+
+/* Footer Styles */
+.footer {
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    border-top: 1px solid #2a2a3e;
+    margin-top: auto;
+    padding: 2rem 0;
+    position: relative;
+    bottom: 0;
+    width: 100%;
+}
+
+.footer-content {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 0 2rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.footer-links {
+    display: flex;
+    gap: 2rem;
+    align-items: center;
+}
+
+.footer-link {
+    color: #8892b0;
+    text-decoration: none;
+    font-size: 0.9rem;
+    transition: color 0.3s ease;
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-family: inherit;
+}
+
+.footer-link:hover {
+    color: #00d4ff;
+}
+
+.cookie-settings-btn {
+    background: none !important;
+    border: none !important;
+    padding: 0 !important;
+    font-size: 0.9rem !important;
+}
+
+.footer-text {
+    color: #6b7280;
+    font-size: 0.85rem;
+}
+
+.footer-text p {
+    margin: 0;
+}
+
+@media (max-width: 768px) {
+    .footer-content {
+        flex-direction: column;
+        text-align: center;
+        gap: 1.5rem;
+    }
+
+    .footer-links {
+        flex-wrap: wrap;
+        justify-content: center;
+        gap: 1.5rem;
+    }
+}
\ No newline at end of file
diff --git a/public/css/index.css b/public/css/index.css
new file mode 100644
index 0000000..b17ecf5
--- /dev/null
+++ b/public/css/index.css
@@ -0,0 +1,1289 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Inter', sans-serif;
+    background: #0a0a0f;
+    color: #ffffff;
+    min-height: 100vh;
+    background-image:
+        radial-gradient(circle at 20% 80%, #1a1a2e 0%, transparent 50%),
+        radial-gradient(circle at 80% 20%, #16213e 0%, transparent 50%),
+        radial-gradient(circle at 40% 40%, #0f3460 0%, transparent 50%);
+}
+
+.main-container {
+    max-width: 1400px;
+    margin: 0 auto;
+    padding: 2rem;
+    min-height: 100vh;
+}
+
+/* Sticky Header Container */
+.sticky-header {
+    position: -webkit-sticky; /* Safari support */
+    position: sticky;
+    top: 0;
+    z-index: 9999; /* Much higher z-index */
+    margin-bottom: 2rem;
+    padding: 1rem 2rem;
+    background: rgba(15, 23, 42, 0.98); /* More opaque */
+    backdrop-filter: blur(20px);
+    -webkit-backdrop-filter: blur(20px); /* Safari support */
+    border: 1px solid #1e293b;
+    border-radius: 1rem;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 1rem;
+    pointer-events: auto;
+    /* iOS specific fixes */
+    -webkit-transform: translateZ(0);
+    transform: translateZ(0);
+    will-change: transform;
+    /* Mobile specific fixes */
+    min-height: 60px; /* Ensure minimum height */
+    width: 100%;
+    box-sizing: border-box;
+}
+
+/* Language Selector */
+.language-selector {
+    display: inline-block;
+}
+
+/* Mobile Navigation Buttons */
+.mobile-nav-buttons {
+    display: flex;
+    gap: 1rem;
+    align-items: center;
+    flex-wrap: wrap;
+}
+
+.mobile-nav-buttons {
+    display: flex;
+    gap: 1rem;
+    align-items: center;
+    flex-wrap: wrap;
+    position: relative;
+    z-index: 10000; /* Even higher z-index */
+}
+
+.mobile-nav-buttons .admin-login-btn,
+.mobile-nav-buttons .dashboard-btn,
+.mobile-nav-buttons .logout-btn {
+    padding: 1rem 2rem; /* Larger padding */
+    border-radius: 0.5rem;
+    text-decoration: none;
+    font-weight: 600;
+    transition: all 0.3s ease;
+    border: none;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.5rem;
+    font-size: 1rem; /* Larger font */
+    position: relative;
+    z-index: 10001; /* Highest z-index */
+    -webkit-tap-highlight-color: transparent;
+    touch-action: manipulation;
+    user-select: none;
+    /* Mobile specific */
+    min-height: 50px; /* Larger touch target */
+    min-width: 120px; /* Larger touch target */
+    flex-shrink: 0; /* Don't shrink */
+    white-space: nowrap; /* Don't wrap text */
+}
+
+.mobile-nav-buttons .admin-login-btn {
+    background: #f59e0b;
+    color: white;
+}
+
+.mobile-nav-buttons .dashboard-btn {
+    background: #2563eb;
+    color: white;
+}
+
+.mobile-nav-buttons .logout-btn {
+    background: #dc2626;
+    color: white;
+}
+
+.mobile-nav-buttons .admin-login-btn:hover,
+.mobile-nav-buttons .dashboard-btn:hover,
+.mobile-nav-buttons .logout-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+}
+
+.mobile-nav-buttons .admin-login-btn:hover {
+    background: #d97706;
+    box-shadow: 0 4px 12px rgba(245, 158, 11, 0.4);
+}
+
+.mobile-nav-buttons .dashboard-btn:hover {
+    background: #1d4ed8;
+    box-shadow: 0 4px 12px rgba(37, 99, 235, 0.4);
+}
+
+.mobile-nav-buttons .logout-btn:hover {
+    background: #b91c1c;
+    box-shadow: 0 4px 12px rgba(220, 38, 38, 0.4);
+}
+
+.language-selector select {
+    padding: 0.5rem 1rem;
+    background: rgba(15, 23, 42, 0.9);
+    border: 1px solid #334155;
+    border-radius: 0.5rem;
+    color: #ffffff;
+    font-size: 0.9rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    backdrop-filter: blur(10px);
+    padding-left: 2.5rem;
+    background-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="20" height="15" viewBox="0 0 20 15"><rect width="20" height="5" fill="%23000000"/><rect y="5" width="20" height="5" fill="%23DD0000"/><rect y="10" width="20" height="5" fill="%23FFCE00"/></svg>');
+    background-repeat: no-repeat;
+    background-position: 0.5rem center;
+    background-size: 20px 15px;
+}
+
+.language-selector select:hover {
+    border-color: #00d4ff;
+    box-shadow: 0 0 0 2px rgba(0, 212, 255, 0.1);
+}
+
+.language-selector select:focus {
+    outline: none;
+    border-color: #00d4ff;
+    box-shadow: 0 0 0 3px rgba(0, 212, 255, 0.2);
+}
+
+.header-section {
+    text-align: center;
+    margin-bottom: 3rem;
+}
+
+.main-title {
+    font-size: 4rem;
+    font-weight: 700;
+    background: linear-gradient(135deg, #00d4ff, #ff6b35, #ffd700);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    margin-bottom: 0.5rem;
+    letter-spacing: -0.02em;
+}
+
+.tagline {
+    font-size: 1.2rem;
+    color: #8892b0;
+    font-weight: 300;
+}
+
+.dashboard-grid {
+    display: grid;
+    grid-template-columns: 1fr 2fr 1fr;
+    gap: 2rem;
+    margin-bottom: 2rem;
+}
+
+.control-panel {
+    background: rgba(15, 23, 42, 0.8);
+    border: 1px solid #1e293b;
+    border-radius: 1rem;
+    padding: 2rem;
+    backdrop-filter: blur(20px);
+}
+
+.control-group {
+    margin-bottom: 1.5rem;
+}
+
+.control-label {
+    display: block;
+    margin-bottom: 0.5rem;
+    font-size: 0.9rem;
+    font-weight: 500;
+    color: #cbd5e1;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.custom-select {
+    width: 100%;
+    padding: 1rem;
+    background: #1e293b;
+    border: 2px solid #334155;
+    border-radius: 0.75rem;
+    color: #ffffff;
+    font-size: 1rem;
+    font-family: inherit;
+    transition: all 0.2s ease;
+}
+
+.custom-select:focus {
+    outline: none;
+    border-color: #00d4ff;
+    box-shadow: 0 0 0 3px rgba(0, 212, 255, 0.1);
+}
+
+/* Location Control Layout */
+.location-control {
+    display: flex;
+    gap: 0.75rem;
+    align-items: center;
+}
+
+.location-select {
+    flex: 1;
+}
+
+.location-btn {
+    padding: 1rem 1.5rem;
+    background: linear-gradient(135deg, #10b981, #059669);
+    border: none;
+    border-radius: 0.75rem;
+    color: white;
+    font-weight: 600;
+    font-size: 0.9rem;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    white-space: nowrap;
+    min-width: 140px;
+}
+
+.location-btn:hover {
+    background: linear-gradient(135deg, #059669, #047857);
+    transform: translateY(-1px);
+    box-shadow: 0 4px 12px rgba(16, 185, 129, 0.3);
+}
+
+.location-btn:disabled {
+    background: #374151;
+    color: #9ca3af;
+    cursor: not-allowed;
+    transform: none;
+    box-shadow: none;
+}
+
+.location-btn.loading {
+    background: linear-gradient(135deg, #6366f1, #4f46e5);
+    position: relative;
+    overflow: hidden;
+}
+
+.location-btn.loading::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: -100%;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.3), transparent);
+    animation: loading-sweep 1.5s infinite;
+}
+
+@keyframes loading-sweep {
+    0% {
+        left: -100%;
+    }
+
+    100% {
+        left: 100%;
+    }
+}
+
+/* Horizontal Time Tabs */
+.time-tabs {
+    display: flex;
+    background: #1e293b;
+    border: 2px solid #334155;
+    border-radius: 0.75rem;
+    padding: 0.25rem;
+    gap: 0.25rem;
+}
+
+.time-tab {
+    flex: 1;
+    min-width: 0;
+    padding: 0.75rem 1rem;
+    background: transparent;
+    border: none;
+    border-radius: 0.5rem;
+    color: #94a3b8;
+    font-size: 0.875rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.5rem;
+    white-space: nowrap;
+}
+
+.time-tab:hover {
+    background: #334155;
+    color: #e2e8f0;
+    transform: translateY(-1px);
+}
+
+.time-tab.active {
+    background: linear-gradient(135deg, #00d4ff, #0891b2);
+    color: white;
+    box-shadow: 0 4px 12px rgba(0, 212, 255, 0.3);
+}
+
+.time-tab.active:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 6px 16px rgba(0, 212, 255, 0.4);
+}
+
+.tab-icon {
+    font-size: 1rem;
+    flex-shrink: 0;
+}
+
+.tab-text {
+    font-size: 0.875rem;
+    font-weight: 500;
+}
+
+.refresh-btn {
+    width: 100%;
+    padding: 2rem;
+    background: linear-gradient(135deg, #00d4ff, #0891b2);
+    border: none;
+    border-radius: 0.75rem;
+    color: white;
+    font-weight: 600;
+    font-size: 1rem;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-top: 1.5rem;
+}
+
+.refresh-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 10px 25px rgba(0, 212, 255, 0.3);
+}
+
+.stats-panel {
+    background: rgba(15, 23, 42, 0.8);
+    border: 1px solid #1e293b;
+    border-radius: 1rem;
+    padding: 2rem;
+    backdrop-filter: blur(20px);
+}
+
+.admin-panel {
+    background: rgba(15, 23, 42, 0.8);
+    border: 1px solid #1e293b;
+    border-radius: 1rem;
+    padding: 2rem;
+    backdrop-filter: blur(20px);
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+}
+
+.admin-buttons {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.admin-btn {
+    padding: 1rem 1.5rem;
+    border: none;
+    border-radius: 0.75rem;
+    color: white;
+    font-weight: 600;
+    font-size: 0.9rem;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    text-decoration: none;
+    display: inline-block;
+    text-align: center;
+    width: 100%;
+}
+
+.admin-login-btn {
+    background: linear-gradient(135deg, #ff6b35, #f7931e);
+}
+
+.admin-login-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 10px 25px rgba(255, 107, 53, 0.3);
+}
+
+.dashboard-btn {
+    background: linear-gradient(135deg, #00d4ff, #0891b2);
+}
+
+.dashboard-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 10px 25px rgba(0, 212, 255, 0.3);
+}
+
+.logout-btn {
+    background: linear-gradient(135deg, #dc3545, #c82333);
+}
+
+.logout-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 10px 25px rgba(220, 53, 69, 0.3);
+}
+
+.stats-grid {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: 1.5rem;
+    height: 100%;
+}
+
+.stat-card {
+    text-align: center;
+    padding: 1rem;
+    background: linear-gradient(135deg, rgba(0, 212, 255, 0.1), rgba(255, 107, 53, 0.1));
+    border-radius: 0.75rem;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.stat-value {
+    font-size: 2.5rem;
+    font-weight: 700;
+    color: #00d4ff;
+    margin-bottom: 0.25rem;
+}
+
+.stat-label {
+    font-size: 0.8rem;
+    color: #8892b0;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.leaderboard-container {
+    background: rgba(15, 23, 42, 0.8);
+    border: 1px solid #1e293b;
+    border-radius: 1rem;
+    backdrop-filter: blur(20px);
+    overflow: hidden;
+}
+
+.leaderboard-header {
+    padding: 2rem;
+    background: linear-gradient(135deg, #1e293b, #0f172a);
+    border-bottom: 1px solid #334155;
+}
+
+.active-filters {
+    font-size: 1.5rem;
+    font-weight: 600;
+    color: #ffffff;
+    margin-bottom: 0.5rem;
+}
+
+.last-sync {
+    font-size: 0.9rem;
+    color: #64748b;
+}
+
+.rankings-list {
+    max-height: 600px;
+    overflow-y: auto;
+    scroll-behavior: smooth;
+}
+
+.rankings-list::-webkit-scrollbar {
+    width: 6px;
+}
+
+.rankings-list::-webkit-scrollbar-track {
+    background: #1e293b;
+}
+
+.rankings-list::-webkit-scrollbar-thumb {
+    background: #475569;
+    border-radius: 3px;
+}
+
+.rank-entry {
+    display: grid;
+    grid-template-columns: 80px 1fr auto auto;
+    align-items: center;
+    padding: 1.5rem 2rem;
+    border-bottom: 1px solid rgba(51, 65, 85, 0.5);
+    transition: all 0.2s ease;
+    position: relative;
+}
+
+.rank-entry:hover {
+    background: rgba(0, 212, 255, 0.05);
+    border-left: 4px solid #00d4ff;
+}
+
+.rank-entry:last-child {
+    border-bottom: none;
+}
+
+.position {
+    font-size: 2rem;
+    font-weight: 700;
+    text-align: center;
+}
+
+.position.gold {
+    color: #ffd700;
+    text-shadow: 0 0 20px rgba(255, 215, 0, 0.5);
+}
+
+.position.silver {
+    color: #c0c0c0;
+    text-shadow: 0 0 20px rgba(192, 192, 192, 0.3);
+}
+
+.position.bronze {
+    color: #cd7f32;
+    text-shadow: 0 0 20px rgba(205, 127, 50, 0.3);
+}
+
+.player-data {
+    padding-left: 1rem;
+}
+
+.player-name {
+    font-size: 1.3rem;
+    font-weight: 600;
+    color: #ffffff;
+    margin-bottom: 0.25rem;
+}
+
+.player-meta {
+    font-size: 0.9rem;
+    color: #8892b0;
+    display: flex;
+    gap: 1rem;
+    align-items: center;
+}
+
+.location-tag {
+    background: rgba(0, 212, 255, 0.2);
+    color: #00d4ff;
+    padding: 0.25rem 0.5rem;
+    border-radius: 0.25rem;
+    font-size: 0.8rem;
+    font-weight: 500;
+}
+
+.time-result {
+    font-family: 'Courier New', monospace;
+    font-size: 2.5rem;
+    font-weight: 700;
+    color: #ffffff;
+    text-align: right;
+}
+
+.trophy-icon {
+    font-size: 2rem;
+    margin-left: 1rem;
+}
+
+.empty-state {
+    text-align: center;
+    padding: 4rem 2rem;
+    color: #64748b;
+}
+
+.empty-icon {
+    font-size: 4rem;
+    margin-bottom: 1rem;
+}
+
+.empty-title {
+    font-size: 1.5rem;
+    font-weight: 600;
+    margin-bottom: 0.5rem;
+    color: #8892b0;
+}
+
+.empty-description {
+    font-size: 1rem;
+    line-height: 1.6;
+}
+
+
+.pulse-animation {
+    animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+    0% {
+        opacity: 1;
+    }
+
+    50% {
+        opacity: 0.7;
+    }
+
+    100% {
+        opacity: 1;
+    }
+}
+
+/* Notification Bubble Styles */
+.notification-bubble {
+    position: fixed;
+    top: 2rem;
+    left: 50%;
+    transform: translateX(-50%);
+    background: linear-gradient(135deg, #00d4ff, #0891b2);
+    color: white;
+    padding: 1rem 2rem;
+    border-radius: 1rem;
+    box-shadow: 0 10px 25px rgba(0, 212, 255, 0.3);
+    z-index: 100000; /* Much higher than sticky header (99999) */
+    opacity: 0;
+    transform: translateX(-50%) translateY(-20px);
+    transition: all 0.3s ease;
+    backdrop-filter: blur(20px);
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    max-width: 400px;
+    text-align: center;
+}
+
+.notification-bubble.show {
+    opacity: 1;
+    transform: translateX(-50%) translateY(0);
+}
+
+.notification-bubble.hide {
+    opacity: 0;
+    transform: translateX(-50%) translateY(-20px);
+}
+
+.notification-content {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.notification-icon {
+    font-size: 1.5rem;
+    animation: bounce 0.6s ease-in-out;
+}
+
+.notification-text {
+    flex: 1;
+}
+
+.notification-title {
+    font-weight: 600;
+    font-size: 1rem;
+    margin-bottom: 0.25rem;
+}
+
+.notification-subtitle {
+    font-size: 0.85rem;
+    opacity: 0.9;
+}
+
+@keyframes bounce {
+
+    0%,
+    20%,
+    50%,
+    80%,
+    100% {
+        transform: translateY(0);
+    }
+
+    40% {
+        transform: translateY(-10px);
+    }
+
+    60% {
+        transform: translateY(-5px);
+    }
+}
+
+@keyframes slideIn {
+    from {
+        opacity: 0;
+        transform: translateX(-50%) translateY(-20px);
+    }
+
+    to {
+        opacity: 1;
+        transform: translateX(-50%) translateY(0);
+    }
+}
+
+@keyframes slideOut {
+    from {
+        opacity: 1;
+        transform: translateX(-50%) translateY(0);
+    }
+
+    to {
+        opacity: 0;
+        transform: translateX(-50%) translateY(-20px);
+    }
+}
+
+/* Mobile First Responsive Design */
+@media (max-width: 1024px) {
+    .dashboard-grid {
+        grid-template-columns: 1fr 1fr;
+        gap: 1.5rem;
+    }
+
+    .stats-grid {
+        grid-template-columns: repeat(3, 1fr);
+    }
+    
+    .admin-panel {
+        grid-column: 1 / -1;
+    }
+}
+
+@media (max-width: 768px) {
+    .main-container {
+        padding: 1rem;
+        max-width: 100%;
+    }
+
+    .sticky-header {
+        flex-direction: column;
+        gap: 1rem;
+        padding: 1rem;
+        margin-bottom: 1rem;
+    }
+
+    .language-selector {
+        order: -1;
+        text-align: center;
+        width: 100%;
+    }
+
+    .mobile-nav-buttons {
+        flex-direction: column;
+        gap: 0.5rem;
+        width: 100%;
+    }
+
+    .main-title {
+        font-size: 2.5rem;
+        margin-bottom: 0.5rem;
+    }
+
+    .tagline {
+        font-size: 1rem;
+    }
+
+    .header-section {
+        margin-bottom: 2rem;
+        margin-top: 1rem;
+    }
+
+    .dashboard-grid {
+        grid-template-columns: 1fr;
+        gap: 1.5rem;
+        margin-bottom: 1.5rem;
+    }
+    
+    .admin-panel {
+        grid-column: 1;
+        order: -1; /* Admin panel kommt zuerst */
+    }
+    
+    .admin-buttons {
+        flex-direction: row;
+        gap: 0.75rem;
+    }
+    
+    .admin-btn {
+        flex: 1;
+        padding: 0.75rem 1rem;
+        font-size: 0.8rem;
+    }
+
+    .control-panel {
+        padding: 1.5rem;
+    }
+
+    .control-group {
+        margin-bottom: 1rem;
+    }
+
+    .custom-select {
+        padding: 1rem;
+        font-size: 1rem;
+    }
+
+    .location-control {
+        flex-direction: column;
+        gap: 0.75rem;
+    }
+
+    .location-btn {
+        width: 100%;
+        min-width: auto;
+        padding: 1rem;
+        font-size: 1rem;
+    }
+
+    .time-tabs {
+        flex-direction: column;
+        gap: 0.5rem;
+        padding: 0.5rem;
+    }
+
+    .time-tab {
+        padding: 1rem;
+        justify-content: flex-start;
+        border-radius: 0.75rem;
+        min-height: 44px;
+        touch-action: manipulation;
+    }
+
+    .tab-text {
+        font-size: 1rem;
+    }
+
+    .refresh-btn {
+        padding: 1rem;
+        font-size: 1rem;
+        min-height: 44px;
+        touch-action: manipulation;
+    }
+
+    .stats-panel {
+        padding: 1.5rem;
+    }
+
+    .stats-grid {
+        grid-template-columns: 1fr;
+        gap: 1rem;
+    }
+
+    .stat-card {
+        padding: 1rem;
+    }
+
+    .stat-value {
+        font-size: 2rem;
+    }
+
+    .stat-label {
+        font-size: 0.8rem;
+    }
+
+    .leaderboard-container {
+        margin-top: 1rem;
+    }
+
+    .leaderboard-header {
+        padding: 1.5rem;
+    }
+
+    .active-filters {
+        font-size: 1.2rem;
+    }
+
+    .last-sync {
+        font-size: 0.8rem;
+    }
+
+    .rankings-list {
+        max-height: 500px;
+        -webkit-overflow-scrolling: touch;
+    }
+
+    .rank-entry {
+        grid-template-columns: 50px 1fr auto;
+        padding: 1rem;
+        gap: 0.75rem;
+        min-height: 60px;
+    }
+
+    .position {
+        font-size: 1.5rem;
+    }
+
+    .player-data {
+        padding-left: 0.5rem;
+    }
+
+    .player-name {
+        font-size: 1.1rem;
+        margin-bottom: 0.25rem;
+    }
+
+    .player-meta {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 0.25rem;
+    }
+
+    .location-tag {
+        font-size: 0.75rem;
+        padding: 0.2rem 0.4rem;
+    }
+
+    .time-result {
+        font-size: 1.5rem;
+    }
+
+    .trophy-icon {
+        display: none;
+    }
+
+
+    .notification-bubble {
+        top: 5rem; /* Below the sticky header */
+        left: 1rem;
+        right: 1rem;
+        transform: none;
+        max-width: none;
+        padding: 1rem;
+        z-index: 100000; /* Ensure it's above sticky header */
+    }
+
+    .notification-bubble.show {
+        transform: none;
+    }
+
+    .notification-bubble.hide {
+        transform: none;
+    }
+}
+
+/* Extra small devices (phones in portrait) */
+@media (max-width: 480px) {
+    .main-container {
+        padding: 0.5rem;
+    }
+
+    .sticky-header {
+        padding: 0.75rem;
+        margin-bottom: 0.75rem;
+    }
+
+    .main-title {
+        font-size: 2rem;
+    }
+
+    .tagline {
+        font-size: 0.9rem;
+    }
+
+    .control-panel {
+        padding: 1rem;
+    }
+
+    .stats-panel {
+        padding: 1rem;
+    }
+    
+    .admin-panel {
+        padding: 1rem;
+    }
+    
+    .admin-buttons {
+        flex-direction: column;
+        gap: 0.5rem;
+    }
+    
+    .admin-btn {
+        padding: 0.75rem;
+        font-size: 0.75rem;
+    }
+
+    .leaderboard-header {
+        padding: 1rem;
+    }
+
+    .active-filters {
+        font-size: 1rem;
+    }
+
+    .rank-entry {
+        grid-template-columns: 40px 1fr auto;
+        padding: 0.75rem;
+        gap: 0.5rem;
+        min-height: 50px;
+    }
+
+    .position {
+        font-size: 1.25rem;
+    }
+
+    .player-name {
+        font-size: 1rem;
+    }
+
+    .time-result {
+        font-size: 1.25rem;
+    }
+
+    .time-tabs {
+        flex-direction: row;
+        overflow-x: auto;
+        padding: 0.25rem;
+        gap: 0.25rem;
+        -webkit-overflow-scrolling: touch;
+    }
+
+    .time-tab {
+        min-width: 80px;
+        padding: 0.75rem 0.5rem;
+        flex-direction: column;
+        gap: 0.25rem;
+        justify-content: center;
+    }
+
+    .tab-icon {
+        font-size: 1.2rem;
+    }
+
+    .tab-text {
+        font-size: 0.75rem;
+    }
+
+}
+
+/* Landscape orientation on mobile */
+@media (max-width: 768px) and (orientation: landscape) {
+    .sticky-header {
+        flex-direction: row;
+        justify-content: space-between;
+    }
+
+    .mobile-nav-buttons {
+        flex-direction: row;
+        flex-wrap: wrap;
+        justify-content: flex-end;
+    }
+
+    .header-section {
+        margin-top: 1rem;
+        margin-bottom: 1.5rem;
+    }
+
+    .main-title {
+        font-size: 2rem;
+    }
+
+
+    .time-tabs {
+        flex-direction: row;
+        overflow-x: auto;
+        -webkit-overflow-scrolling: touch;
+    }
+
+    .time-tab {
+        min-width: 100px;
+        padding: 0.75rem 1rem;
+        flex-direction: row;
+        justify-content: center;
+    }
+
+    .stats-grid {
+        grid-template-columns: repeat(3, 1fr);
+    }
+
+    .rank-entry {
+        grid-template-columns: 60px 1fr auto;
+        padding: 0.75rem 1rem;
+    }
+
+    .position {
+        font-size: 1.5rem;
+    }
+
+    .time-result {
+        font-size: 1.75rem;
+    }
+}
+
+/* Mobile-specific sticky header fixes */
+@media (max-width: 768px) {
+    .sticky-header {
+        position: fixed !important;
+        top: 0 !important;
+        left: 0 !important;
+        right: 0 !important;
+        width: 100% !important;
+        z-index: 99999 !important;
+        margin-bottom: 0 !important;
+        border-radius: 0 !important;
+        padding: 1rem !important;
+    }
+    
+    .main-container {
+        padding-top: 80px !important;
+    }
+    
+    .mobile-nav-buttons {
+        gap: 0.5rem;
+    }
+    
+    .mobile-nav-buttons .admin-login-btn,
+    .mobile-nav-buttons .dashboard-btn,
+    .mobile-nav-buttons .logout-btn {
+        padding: 0.75rem 1.5rem;
+        font-size: 0.9rem;
+        min-height: 44px;
+        min-width: 100px;
+    }
+}
+
+/* Touch-friendly improvements for mobile */
+@media (max-width: 768px) {
+    .time-tab {
+        touch-action: manipulation;
+    }
+
+    .location-btn {
+        touch-action: manipulation;
+    }
+
+    .refresh-btn {
+        touch-action: manipulation;
+    }
+
+    .rank-entry {
+        touch-action: manipulation;
+    }
+
+    .custom-select {
+        -webkit-appearance: none;
+        appearance: none;
+        touch-action: manipulation;
+    }
+
+    /* Improve scrolling performance */
+    .rankings-list {
+        scroll-behavior: smooth;
+    }
+
+    /* Better spacing for mobile */
+    .control-panel {
+        margin-bottom: 1rem;
+    }
+
+    .stats-panel {
+        margin-bottom: 1rem;
+    }
+}
+
+/* Footer Styles */
+.footer {
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    border-top: 1px solid #2a2a3e;
+    margin-top: 3rem;
+    padding: 2rem 0;
+}
+
+.footer-content {
+    max-width: 1400px;
+    margin: 0 auto;
+    padding: 0 2rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.footer-links {
+    display: flex;
+    gap: 2rem;
+    align-items: center;
+}
+
+.footer-link {
+    color: #8892b0;
+    text-decoration: none;
+    font-size: 0.9rem;
+    transition: color 0.3s ease;
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-family: inherit;
+}
+
+.footer-link:hover {
+    color: #00d4ff;
+}
+
+.cookie-settings-btn {
+    background: none !important;
+    border: none !important;
+    padding: 0 !important;
+    font-size: 0.9rem !important;
+}
+
+.footer-text {
+    color: #6b7280;
+    font-size: 0.85rem;
+}
+
+.footer-text p {
+    margin: 0;
+}
+
+@media (max-width: 768px) {
+    .footer-content {
+        flex-direction: column;
+        text-align: center;
+        gap: 1.5rem;
+    }
+
+    .footer-links {
+        flex-wrap: wrap;
+        justify-content: center;
+        gap: 1.5rem;
+    }
+}
+
+/* iOS Sticky Header Fallback */
+@supports not (position: sticky) {
+    .sticky-header {
+        position: fixed !important;
+        top: 0 !important;
+        left: 0 !important;
+        right: 0 !important;
+        width: 100% !important;
+        z-index: 1000 !important;
+    }
+    
+    body {
+        padding-top: 80px !important;
+    }
+}
+
+/* iOS Safari specific fixes */
+@supports (-webkit-touch-callout: none) {
+    .sticky-header {
+        position: -webkit-sticky;
+        position: sticky;
+        -webkit-transform: translateZ(0);
+        transform: translateZ(0);
+    }
+}
\ No newline at end of file
diff --git a/public/css/login.css b/public/css/login.css
new file mode 100644
index 0000000..69cb817
--- /dev/null
+++ b/public/css/login.css
@@ -0,0 +1,486 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Inter', sans-serif;
+    background: #0a0a0f;
+    color: #ffffff;
+    min-height: 100vh;
+    background-image: 
+        radial-gradient(circle at 20% 80%, #1a1a2e 0%, transparent 50%),
+        radial-gradient(circle at 80% 20%, #16213e 0%, transparent 50%),
+        radial-gradient(circle at 40% 40%, #0f3460 0%, transparent 50%);
+    position: relative;
+    display: flex;
+    flex-direction: column;
+}
+
+.main-content {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 2rem 0;
+}
+
+.back-button {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    background: rgba(30, 41, 59, 0.95);
+    backdrop-filter: blur(20px);
+    border: 1px solid rgba(51, 65, 85, 0.3);
+    border-radius: 12px;
+    padding: 12px 20px;
+    color: #00d4ff;
+    text-decoration: none;
+    font-weight: 600;
+    font-size: 0.9rem;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    transition: all 0.3s ease;
+    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.2);
+    z-index: 1000;
+}
+
+.back-button:hover {
+    background: #00d4ff;
+    color: #ffffff;
+    transform: translateY(-2px);
+    box-shadow: 0 8px 25px rgba(0, 212, 255, 0.3);
+}
+
+.back-button::before {
+    content: "← ";
+    margin-right: 5px;
+}
+
+.container {
+    background: rgba(30, 41, 59, 0.95);
+    backdrop-filter: blur(20px);
+    border: 1px solid rgba(51, 65, 85, 0.3);
+    padding: 2.5rem;
+    border-radius: 1.5rem;
+    box-shadow: 
+        0 25px 50px rgba(0, 0, 0, 0.3),
+        0 0 0 1px rgba(0, 212, 255, 0.1);
+    width: 100%;
+    max-width: 420px;
+}
+
+.logo {
+    text-align: center;
+    margin-bottom: 2rem;
+}
+
+.logo h1 {
+    font-size: 2.5rem;
+    font-weight: 700;
+    background: linear-gradient(135deg, #00d4ff, #ff6b35, #ffd700);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    margin-bottom: 0.5rem;
+    letter-spacing: -0.02em;
+}
+
+.logo p {
+    color: #94a3b8;
+    margin-top: 0.5rem;
+    font-size: 1rem;
+    font-weight: 400;
+}
+
+.form-container {
+    display: none;
+}
+
+.form-container.active {
+    display: block;
+}
+
+.form-group {
+    margin-bottom: 1.5rem;
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: 0.5rem;
+    color: #e2e8f0;
+    font-weight: 500;
+    font-size: 0.875rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.form-group input {
+    width: 100%;
+    padding: 1rem;
+    background: #1e293b;
+    border: 2px solid #334155;
+    border-radius: 0.75rem;
+    color: #ffffff;
+    font-size: 1rem;
+    font-family: inherit;
+    transition: all 0.2s ease;
+}
+
+.form-group input:focus {
+    outline: none;
+    border-color: #00d4ff;
+    box-shadow: 0 0 0 3px rgba(0, 212, 255, 0.1);
+}
+
+.form-group input::placeholder {
+    color: #64748b;
+}
+
+.btn {
+    width: 100%;
+    padding: 1rem;
+    border: none;
+    border-radius: 0.75rem;
+    font-size: 1rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    margin-bottom: 1rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.btn-primary {
+    background: linear-gradient(135deg, #00d4ff, #0891b2);
+    color: white;
+    box-shadow: 0 4px 12px rgba(0, 212, 255, 0.3);
+}
+
+.btn-primary:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 6px 16px rgba(0, 212, 255, 0.4);
+}
+
+.btn-secondary {
+    background: transparent;
+    color: #00d4ff;
+    border: 2px solid #00d4ff;
+}
+
+.btn-secondary:hover {
+    background: #00d4ff;
+    color: #0a0a0f;
+}
+
+.toggle-form {
+    text-align: center;
+    margin-top: 1rem;
+}
+
+.toggle-form button {
+    background: none;
+    border: none;
+    color: #00d4ff;
+    cursor: pointer;
+    text-decoration: underline;
+    font-size: 0.9rem;
+    transition: color 0.2s ease;
+}
+
+.toggle-form button:hover {
+    color: #0891b2;
+}
+
+.message {
+    padding: 1rem;
+    border-radius: 0.75rem;
+    margin-bottom: 1rem;
+    text-align: center;
+    font-weight: 500;
+    border: 1px solid;
+}
+
+.message.success {
+    background: rgba(34, 197, 94, 0.1);
+    color: #22c55e;
+    border-color: rgba(34, 197, 94, 0.3);
+}
+
+.message.error {
+    background: rgba(239, 68, 68, 0.1);
+    color: #ef4444;
+    border-color: rgba(239, 68, 68, 0.3);
+}
+
+.password-reset-container {
+    display: none;
+    margin-top: 1rem;
+    padding: 1rem;
+    background: rgba(239, 68, 68, 0.05);
+    border: 1px solid rgba(239, 68, 68, 0.2);
+    border-radius: 0.75rem;
+    text-align: center;
+}
+
+.password-reset-container.active {
+    display: block;
+}
+
+.password-reset-container p {
+    color: #ef4444;
+    margin-bottom: 1rem;
+    font-size: 0.9rem;
+}
+
+.btn-reset {
+    background: linear-gradient(135deg, #ef4444, #dc2626);
+    color: white;
+    box-shadow: 0 4px 12px rgba(239, 68, 68, 0.3);
+}
+
+.btn-reset:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 6px 16px rgba(239, 68, 68, 0.4);
+}
+
+.loading {
+    display: none;
+    text-align: center;
+    color: #94a3b8;
+}
+
+.loading.active {
+    display: block;
+}
+
+.spinner {
+    border: 3px solid #334155;
+    border-top: 3px solid #00d4ff;
+    border-radius: 50%;
+    width: 30px;
+    height: 30px;
+    animation: spin 1s linear infinite;
+    margin: 0 auto 1rem;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    .container {
+        margin: 1rem;
+        padding: 2rem;
+        max-width: none;
+    }
+
+    .logo h1 {
+        font-size: 2rem;
+    }
+
+    .form-group input {
+        padding: 0.875rem;
+    }
+
+    .btn {
+        padding: 0.875rem;
+    }
+}
+
+@media (max-width: 480px) {
+    .container {
+        margin: 0.5rem;
+        padding: 1.5rem;
+    }
+
+    .logo h1 {
+        font-size: 1.75rem;
+    }
+
+    .logo p {
+        font-size: 0.875rem;
+    }
+
+    .back-button {
+        top: 15px;
+        right: 15px;
+        padding: 10px 15px;
+        font-size: 0.8rem;
+    }
+}
+
+/* OAuth Container */
+.oauth-container {
+    margin-bottom: 20px;
+}
+
+.btn-google {
+    width: 100%;
+    background: white;
+    color: #333;
+    border: 1px solid #dadce0;
+    padding: 12px 16px;
+    border-radius: 8px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 12px;
+    font-size: 0.95rem;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+.btn-google:hover {
+    background: #f8f9fa;
+    border-color: #c1c7cd;
+    transform: translateY(-1px);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+}
+
+.btn-google:active {
+    transform: translateY(0);
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+.btn-google svg {
+    flex-shrink: 0;
+}
+
+.btn-discord {
+    width: 100%;
+    background: #5865F2;
+    color: white;
+    border: 1px solid #4752C4;
+    padding: 12px 16px;
+    border-radius: 8px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 12px;
+    font-size: 0.95rem;
+    box-shadow: 0 1px 3px rgba(88, 101, 242, 0.3);
+    margin-top: 10px;
+}
+
+.btn-discord:hover {
+    background: #4752C4;
+    border-color: #3C45A5;
+    transform: translateY(-1px);
+    box-shadow: 0 4px 12px rgba(88, 101, 242, 0.4);
+}
+
+.btn-discord:active {
+    transform: translateY(0);
+    box-shadow: 0 1px 3px rgba(88, 101, 242, 0.3);
+}
+
+.btn-discord svg {
+    flex-shrink: 0;
+}
+
+/* Divider */
+.divider {
+    position: relative;
+    text-align: center;
+    margin: 20px 0;
+    color: #64748b;
+    font-size: 0.9rem;
+}
+
+.divider::before {
+    content: '';
+    position: absolute;
+    top: 50%;
+    left: 0;
+    right: 0;
+    height: 1px;
+    background: linear-gradient(to right, transparent, #334155, transparent);
+}
+
+.divider span {
+    background: #0a0a0f;
+    padding: 0 16px;
+    position: relative;
+    z-index: 1;
+}
+
+/* Footer Styles */
+.footer {
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    border-top: 1px solid #2a2a3e;
+    margin-top: 3rem;
+    padding: 2rem 0;
+}
+
+.footer-content {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 0 2rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.footer-links {
+    display: flex;
+    gap: 2rem;
+    align-items: center;
+}
+
+.footer-link {
+    color: #8892b0;
+    text-decoration: none;
+    font-size: 0.9rem;
+    transition: color 0.3s ease;
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-family: inherit;
+}
+
+.footer-link:hover {
+    color: #00d4ff;
+}
+
+.cookie-settings-btn {
+    background: none !important;
+    border: none !important;
+    padding: 0 !important;
+    font-size: 0.9rem !important;
+}
+
+.footer-text {
+    color: #6b7280;
+    font-size: 0.85rem;
+}
+
+.footer-text p {
+    margin: 0;
+}
+
+@media (max-width: 768px) {
+    .footer-content {
+        flex-direction: column;
+        text-align: center;
+        gap: 1.5rem;
+    }
+    
+    .footer-links {
+        flex-wrap: wrap;
+        justify-content: center;
+        gap: 1.5rem;
+    }
+}
diff --git a/public/css/reset-password.css b/public/css/reset-password.css
new file mode 100644
index 0000000..2401eff
--- /dev/null
+++ b/public/css/reset-password.css
@@ -0,0 +1,305 @@
+/* Reset und Basis-Styles */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: radial-gradient(ellipse at top, #1e293b 0%, #0f172a 50%, #020617 100%);
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: #e2e8f0;
+    line-height: 1.6;
+}
+
+.container {
+    background: rgba(30, 41, 59, 0.95);
+    backdrop-filter: blur(20px);
+    border: 1px solid rgba(51, 65, 85, 0.3);
+    border-radius: 20px;
+    padding: 40px;
+    max-width: 500px;
+    width: 90%;
+    box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);
+    text-align: center;
+}
+
+.logo {
+    font-size: 2.5rem;
+    font-weight: 900;
+    background: linear-gradient(135deg, #00d4ff, #0891b2);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    margin-bottom: 10px;
+    text-transform: uppercase;
+    letter-spacing: 2px;
+}
+
+.tagline {
+    color: #94a3b8;
+    font-size: 0.9rem;
+    margin-bottom: 30px;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+}
+
+.title {
+    font-size: 1.8rem;
+    font-weight: 700;
+    color: #ffffff;
+    margin-bottom: 20px;
+}
+
+.subtitle {
+    color: #cbd5e1;
+    font-size: 1rem;
+    margin-bottom: 30px;
+}
+
+.form-group {
+    margin-bottom: 20px;
+    text-align: left;
+}
+
+.form-label {
+    display: block;
+    color: #e2e8f0;
+    font-weight: 600;
+    margin-bottom: 8px;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    font-size: 0.9rem;
+}
+
+.form-input {
+    width: 100%;
+    padding: 15px 20px;
+    background: #1e293b;
+    border: 2px solid #334155;
+    border-radius: 12px;
+    color: #ffffff;
+    font-size: 1rem;
+    transition: all 0.3s ease;
+}
+
+.form-input:focus {
+    outline: none;
+    border-color: #00d4ff;
+    box-shadow: 0 0 0 3px rgba(0, 212, 255, 0.1);
+}
+
+.form-input::placeholder {
+    color: #64748b;
+}
+
+.btn {
+    width: 100%;
+    padding: 15px 30px;
+    border: none;
+    border-radius: 12px;
+    font-size: 1rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    margin-bottom: 20px;
+}
+
+.btn-primary {
+    background: linear-gradient(135deg, #00d4ff, #0891b2);
+    color: #ffffff;
+    box-shadow: 0 4px 15px rgba(0, 212, 255, 0.3);
+}
+
+.btn-primary:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 8px 25px rgba(0, 212, 255, 0.4);
+}
+
+.btn-primary:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+    transform: none;
+}
+
+.btn-secondary {
+    background: transparent;
+    color: #00d4ff;
+    border: 2px solid #00d4ff;
+}
+
+.btn-secondary:hover {
+    background: #00d4ff;
+    color: #ffffff;
+}
+
+.message {
+    padding: 15px 20px;
+    border-radius: 12px;
+    margin-bottom: 20px;
+    font-weight: 600;
+    text-align: center;
+}
+
+.message.success {
+    background: rgba(34, 197, 94, 0.1);
+    border: 1px solid #22c55e;
+    color: #22c55e;
+}
+
+.message.error {
+    background: rgba(239, 68, 68, 0.1);
+    border: 1px solid #ef4444;
+    color: #ef4444;
+}
+
+.message.info {
+    background: rgba(59, 130, 246, 0.1);
+    border: 1px solid #3b82f6;
+    color: #3b82f6;
+}
+
+.loading {
+    display: none;
+    text-align: center;
+    color: #94a3b8;
+}
+
+.spinner {
+    display: inline-block;
+    width: 20px;
+    height: 20px;
+    border: 3px solid #334155;
+    border-radius: 50%;
+    border-top-color: #00d4ff;
+    animation: spin 1s ease-in-out infinite;
+    margin-right: 10px;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+.back-link {
+    color: #00d4ff;
+    text-decoration: none;
+    font-size: 0.9rem;
+    margin-top: 20px;
+    display: inline-block;
+}
+
+.back-link:hover {
+    color: #0891b2;
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    .container {
+        margin: 20px;
+        padding: 30px 20px;
+    }
+    
+    .logo {
+        font-size: 2rem;
+    }
+    
+    .title {
+        font-size: 1.5rem;
+    }
+    
+    .form-input, .btn {
+        padding: 12px 15px;
+        font-size: 0.9rem;
+    }
+}
+
+@media (max-width: 480px) {
+    .container {
+        margin: 10px;
+        padding: 20px 15px;
+    }
+    
+    .logo {
+        font-size: 1.8rem;
+    }
+    
+    .title {
+        font-size: 1.3rem;
+    }
+}
+
+/* Footer Styles */
+.footer {
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    border-top: 1px solid #2a2a3e;
+    margin-top: 3rem;
+    padding: 2rem 0;
+}
+
+.footer-content {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 0 2rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.footer-links {
+    display: flex;
+    gap: 2rem;
+    align-items: center;
+}
+
+.footer-link {
+    color: #8892b0;
+    text-decoration: none;
+    font-size: 0.9rem;
+    transition: color 0.3s ease;
+    background: none;
+    border: none;
+    cursor: pointer;
+    font-family: inherit;
+}
+
+.footer-link:hover {
+    color: #00d4ff;
+}
+
+.cookie-settings-btn {
+    background: none !important;
+    border: none !important;
+    padding: 0 !important;
+    font-size: 0.9rem !important;
+}
+
+.footer-text {
+    color: #6b7280;
+    font-size: 0.85rem;
+}
+
+.footer-text p {
+    margin: 0;
+}
+
+@media (max-width: 768px) {
+    .footer-content {
+        flex-direction: column;
+        text-align: center;
+        gap: 1.5rem;
+    }
+    
+    .footer-links {
+        flex-wrap: wrap;
+        justify-content: center;
+        gap: 1.5rem;
+    }
+}
diff --git a/public/dashboard.html b/public/dashboard.html
new file mode 100644
index 0000000..87f996e
--- /dev/null
+++ b/public/dashboard.html
@@ -0,0 +1,902 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>SPEEDRUN ARENA - Admin Dashboard</title>
+    <link rel="icon" type="image/x-icon" href="/pictures/favicon.ico">
+    <link rel="manifest" href="/manifest.json">
+    <meta name="mobile-web-app-capable" content="yes">
+    <meta name="apple-mobile-web-app-capable" content="yes">
+    <meta name="apple-mobile-web-app-status-bar-style" content="default">
+    <meta name="apple-mobile-web-app-title" content="Ninja Cross">
+    <link rel="apple-touch-icon" href="/pictures/favicon.ico">
+    <script src="https://unpkg.com/@supabase/supabase-js@2"></script>
+    <!-- QR Code Scanner Library -->
+    <script src="https://unpkg.com/jsqr@1.4.0/dist/jsQR.js"></script>
+    <link rel="stylesheet" href="/css/dashboard.css">
+    
+    <!-- Notification Permission Script -->
+    <script>
+        // Register Service Worker for iPhone Notifications
+        if ('serviceWorker' in navigator) {
+            navigator.serviceWorker.register('/sw.js')
+                .then(function(registration) {
+                    console.log('✅ Service Worker registered:', registration);
+                })
+                .catch(function(error) {
+                    console.log('❌ Service Worker registration failed:', error);
+                });
+        }
+        
+        // Don't automatically request notification permission
+        // User must click the button to enable push notifications
+        
+        // Convert VAPID key from base64url to Uint8Array
+        function urlBase64ToUint8Array(base64String) {
+            const padding = '='.repeat((4 - base64String.length % 4) % 4);
+            const base64 = (base64String + padding)
+                .replace(/\-/g, '+')
+                .replace(/_/g, '/');
+            
+            const rawData = window.atob(base64);
+            const outputArray = new Uint8Array(rawData.length);
+            
+            for (let i = 0; i < rawData.length; ++i) {
+                outputArray[i] = rawData.charCodeAt(i);
+            }
+            return outputArray;
+        }
+
+        // Convert ArrayBuffer to Base64 string
+        function arrayBufferToBase64(buffer) {
+            const bytes = new Uint8Array(buffer);
+            let binary = '';
+            for (let i = 0; i < bytes.byteLength; i++) {
+                binary += String.fromCharCode(bytes[i]);
+            }
+            return window.btoa(binary);
+        }
+
+        // Push notification state
+        let pushSubscription = null;
+        let pushEnabled = false;
+
+        // Subscribe to push notifications
+        async function subscribeToPush() {
+            try {
+                console.log('🔔 Starting push subscription...');
+                
+                const registration = await navigator.serviceWorker.ready;
+                const vapidPublicKey = 'BJmNVx0C3XeVxeKGTP9c-Z4HcuZNmdk6QdiLocZgCmb-miCS0ESFO3W2TvJlRhhNAShV63pWA5p36BTVSetyTds';
+                const applicationServerKey = urlBase64ToUint8Array(vapidPublicKey);
+                
+                const subscription = await registration.pushManager.subscribe({
+                    userVisibleOnly: true,
+                    applicationServerKey: applicationServerKey
+                });
+                
+                pushSubscription = subscription;
+                
+                // Player ID wird automatisch vom Server aus der Session geholt
+                console.log(`📱 Subscribing to push notifications...`);
+                
+                // Convert ArrayBuffer keys to Base64 strings
+                const p256dhKey = subscription.getKey('p256dh');
+                const authKey = subscription.getKey('auth');
+                
+                // Convert ArrayBuffer to Base64 URL-safe string
+                const p256dhString = arrayBufferToBase64(p256dhKey);
+                const authString = arrayBufferToBase64(authKey);
+                
+                console.log('📱 Converted keys to Base64 strings');
+                console.log('📱 p256dh length:', p256dhString.length);
+                console.log('📱 auth length:', authString.length);
+                
+                // Get current Supabase user ID
+                const { data: { session } } = await supabase.auth.getSession();
+                const supabaseUserId = session?.user?.id || null;
+                
+                // Send subscription to server with player ID
+                const response = await fetch('/api/v1/public/subscribe', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    credentials: 'include', // Include cookies for session
+                    body: JSON.stringify({
+                        endpoint: subscription.endpoint,
+                        keys: {
+                            p256dh: p256dhString,
+                            auth: authString
+                        },
+                        supabaseUserId: supabaseUserId
+                    })
+                });
+                
+                const result = await response.json();
+                if (result.success) {
+                    pushEnabled = true;
+                    updatePushButton();
+                    console.log('✅ Push subscription successful');
+                    
+                    // Store player ID for notifications
+                    if (result.playerId) {
+                        localStorage.setItem('pushPlayerId', result.playerId);
+                    }
+                } else {
+                    throw new Error(result.message);
+                }
+            } catch (error) {
+                console.error('❌ Push subscription failed:', error);
+                pushEnabled = false;
+                updatePushButton();
+            }
+        }
+
+        // Unsubscribe from push notifications
+        async function unsubscribeFromPush() {
+            try {
+                console.log('🔕 Unsubscribing from push notifications...');
+                
+                // Get player ID from localStorage
+                const playerId = localStorage.getItem('pushPlayerId');
+                
+                if (pushSubscription) {
+                    // Store endpoint before unsubscribing
+                    const endpoint = pushSubscription.endpoint;
+                    
+                    await pushSubscription.unsubscribe();
+                    pushSubscription = null;
+                    console.log('✅ Local push subscription removed');
+                    
+                    // Notify server to remove specific subscription from database
+                    if (playerId && endpoint) {
+                        try {
+                            const response = await fetch('/api/v1/public/unsubscribe', {
+                                method: 'POST',
+                                headers: {
+                                    'Content-Type': 'application/json',
+                                },
+                                credentials: 'include', // Include cookies for session
+                                body: JSON.stringify({ 
+                                    playerId: playerId,
+                                    endpoint: endpoint
+                                })
+                            });
+                            
+                            const result = await response.json();
+                            if (result.success) {
+                                console.log('✅ Server notified - specific subscription removed from database');
+                            } else {
+                                console.warn('⚠️ Server notification failed:', result.message);
+                            }
+                        } catch (error) {
+                            console.warn('⚠️ Failed to notify server:', error);
+                        }
+                    }
+                }
+                
+                // Clear stored player ID
+                localStorage.removeItem('pushPlayerId');
+                
+                pushEnabled = false;
+                updatePushButton();
+                console.log('🔕 Push notifications disabled');
+            } catch (error) {
+                console.error('❌ Push unsubscribe failed:', error);
+                pushEnabled = false;
+                updatePushButton();
+            }
+        }
+
+        // Check if user is on iOS
+        function isIOS() {
+            return /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
+        }
+
+        // Check if PWA is installed
+        function isPWAInstalled() {
+            return window.matchMedia('(display-mode: standalone)').matches || 
+                   window.navigator.standalone === true;
+        }
+
+        // Show iOS PWA installation hint
+        function showIOSPWAHint() {
+            if (isIOS() && !isPWAInstalled()) {
+                const hint = document.createElement('div');
+                hint.id = 'ios-pwa-hint';
+                hint.style.cssText = `
+                    position: fixed;
+                    top: 20px;
+                    left: 50%;
+                    transform: translateX(-50%);
+                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                    color: white;
+                    padding: 15px 20px;
+                    border-radius: 10px;
+                    box-shadow: 0 4px 20px rgba(0,0,0,0.3);
+                    z-index: 10000;
+                    max-width: 90%;
+                    text-align: center;
+                    font-size: 14px;
+                    line-height: 1.4;
+                `;
+                hint.innerHTML = `
+                    <div style="display: flex; align-items: center; gap: 10px;">
+                        <span style="font-size: 20px;">📱</span>
+                        <div>
+                            <strong>Push-Benachrichtigungen für iOS</strong><br>
+                            <small>Für Push-Benachrichtigungen auf iOS: Tippe auf <span style="background: rgba(255,255,255,0.2); padding: 2px 6px; border-radius: 4px;">📤 Teilen</span> → <span style="background: rgba(255,255,255,0.2); padding: 2px 6px; border-radius: 4px;">Zum Home-Bildschirm hinzufügen</span></small>
+                        </div>
+                        <button onclick="this.parentElement.parentElement.remove()" style="background: none; border: none; color: white; font-size: 18px; cursor: pointer; padding: 0; margin-left: 10px;">✕</button>
+                    </div>
+                `;
+                document.body.appendChild(hint);
+                
+                // Auto-remove after 10 seconds
+                setTimeout(() => {
+                    if (hint.parentNode) {
+                        hint.remove();
+                    }
+                }, 10000);
+            }
+        }
+
+        // Toggle push notifications
+        async function togglePushNotifications() {
+            if (pushEnabled) {
+                await unsubscribeFromPush();
+            } else {
+                // Check if iOS and not PWA
+                if (isIOS() && !isPWAInstalled()) {
+                    showIOSPWAHint();
+                    return;
+                }
+
+                // Check notification permission first
+                if (Notification.permission === 'denied') {
+                    alert('Push-Benachrichtigungen sind blockiert. Bitte erlaube sie in den Browser-Einstellungen.');
+                    return;
+                }
+                
+                if (Notification.permission === 'default') {
+                    const permission = await Notification.requestPermission();
+                    if (permission !== 'granted') {
+                        alert('Push-Benachrichtigungen wurden nicht erlaubt.');
+                        return;
+                    }
+                }
+                
+                await subscribeToPush();
+            }
+        }
+
+        // Update push button appearance
+        function updatePushButton() {
+            const button = document.getElementById('pushButton');
+            if (!button) {
+                console.log('❌ Push button not found in DOM');
+                return;
+            }
+            
+            console.log(`🔔 Updating push button - Status: ${pushEnabled ? 'ENABLED' : 'DISABLED'}`);
+            
+            if (pushEnabled) {
+                button.classList.add('active');
+                button.setAttribute('data-de', '🔕 Push deaktivieren');
+                button.setAttribute('data-en', '🔕 Disable Push');
+                button.textContent = '🔕 Push deaktivieren';
+                console.log('✅ Button updated to: Push deaktivieren (RED)');
+            } else {
+                button.classList.remove('active');
+                button.setAttribute('data-de', '🔔 Push aktivieren');
+                button.setAttribute('data-en', '🔔 Enable Push');
+                button.textContent = '🔔 Push aktivieren';
+                console.log('✅ Button updated to: Push aktivieren (GREEN)');
+            }
+        }
+
+        // Check existing push subscription on page load
+        async function checkPushStatus() {
+            try {
+                console.log('🔍 Checking push status...');
+                
+                if (!('serviceWorker' in navigator)) {
+                    console.log('❌ Service Worker not supported');
+                    pushEnabled = false;
+                    updatePushButton();
+                    return;
+                }
+                
+                if (!('PushManager' in window)) {
+                    console.log('❌ Push Manager not supported');
+                    pushEnabled = false;
+                    updatePushButton();
+                    return;
+                }
+                
+                const registration = await navigator.serviceWorker.ready;
+                console.log('✅ Service Worker ready');
+                
+                const subscription = await registration.pushManager.getSubscription();
+                console.log('📱 Current subscription:', subscription ? 'EXISTS' : 'NONE');
+                
+                if (subscription) {
+                    pushSubscription = subscription;
+                    pushEnabled = true;
+                    updatePushButton();
+                    console.log('✅ Existing push subscription found and activated');
+                    
+                    // Also check if we have a stored player ID
+                    const storedPlayerId = localStorage.getItem('pushPlayerId');
+                    if (storedPlayerId) {
+                        console.log(`📱 Push subscription linked to player: ${storedPlayerId}`);
+                    }
+                } else {
+                    pushEnabled = false;
+                    updatePushButton();
+                    console.log('ℹ️ No existing push subscription found');
+                }
+            } catch (error) {
+                console.error('❌ Error checking push status:', error);
+                pushEnabled = false;
+                updatePushButton();
+            }
+        }
+    </script>
+</head>
+<body>
+    <div class="main-container">
+        <!-- Sticky Header Container -->
+        <div class="sticky-header">
+            <!-- Language Selector -->
+            <div class="language-selector">
+                <select id="languageSelect" onchange="changeLanguage()">
+                    <option value="de" data-flag="🇩🇪">Deutsch</option>
+                    <option value="en" data-flag="🇺🇸">English</option>
+                </select>
+            </div>
+
+            <div class="nav-buttons">
+                <div class="user-info">
+                    <div class="user-avatar" id="userAvatar">U</div>
+                    <span id="userEmail">user@example.com</span>
+                </div>
+                <button class="btn btn-push" id="pushButton" onclick="togglePushNotifications()" data-de="🔔 Push aktivieren" data-en="🔔 Enable Push">🔔 Push aktivieren</button>
+                <button class="btn btn-pwa" id="pwaButton" onclick="installPWA()" style="display: none;" data-de="📱 App installieren" data-en="📱 Install App">📱 App installieren</button>
+                <a href="/" class="btn btn-primary" data-de="Zurück zu Zeiten" data-en="Back to Times">Back to Times</a>
+                <button class="btn btn-logout" onclick="logout()" data-de="Logout" data-en="Logout">Logout</button>
+            </div>
+        </div>
+
+        <div class="header-section">
+            <h1 class="main-title" data-de="DEIN DASHBOARD" data-en="YOUR DASHBOARD">DEIN DASHBOARD</h1>
+            <p class="tagline" data-de="Verwalte deine Läufe in der NINJACROSS ARENA" data-en="Manage your runs in the NINJACROSS ARENA">Verwalte deine Läufe in der NINJACROSS ARENA</p>
+        </div>
+        <div id="loading" class="loading">
+            <div class="spinner"></div>
+            <p data-de="Lade dein Dashboard..." data-en="Loading your dashboard...">Lade dein Dashboard...</p>
+        </div>
+
+        <div id="dashboardContent" style="display: none;">
+            <div class="welcome-card">
+                <h2 data-de="Dein Dashboard 🥷" data-en="Your Dashboard 🥷">Dein Dashboard 🥷</h2>
+                <p data-de="Willkommen in Deinem Dashboard-Panel! Deine übersichtliche Übersicht aller deiner Läufe." data-en="Welcome to your Dashboard panel! Your clear overview of all your runs.">Willkommen in Deinem Dashboard-Panel! Deine übersichtliche Übersicht aller deiner Läufe.</p>
+                
+            </div>
+
+            <div class="dashboard-grid">
+                <div class="card" id="analyticsCard" style="cursor: pointer;">
+                    <h3 data-de="📊 Analytics" data-en="📊 Analytics">📊 Analytics</h3>
+                    <div id="analyticsPreview" style="display: none;">
+                        <div class="analytics-stats">
+                            <div class="mini-stat">
+                                <div class="mini-stat-number" id="avgTimeThisWeek">--:--</div>
+                                <div class="mini-stat-label">Durchschnitt diese Woche</div>
+                            </div>
+                            <div class="mini-stat">
+                                <div class="mini-stat-number" id="improvementThisWeek">+0.0%</div>
+                                <div class="mini-stat-label">Verbesserung</div>
+                            </div>
+                            <div class="mini-stat">
+                                <div class="mini-stat-number" id="runsThisWeek">0</div>
+                                <div class="mini-stat-label">Läufe diese Woche</div>
+                            </div>
+                        </div>
+                    </div>
+                    <p data-de="Verfolge deine Leistung und überwache wichtige Metriken." data-en="Track your performance and monitor important metrics.">Verfolge deine Leistung und überwache wichtige Metriken.</p>
+                    <button class="btn btn-primary" style="margin-top: 1rem;" onclick="event.stopPropagation(); showAnalytics();" data-de="Analytics öffnen" data-en="Open Analytics">Analytics öffnen</button>
+                </div>
+
+                <div class="card" onclick="showSettings()" style="cursor: pointer;">
+                    <h3 data-de="⚙️ Settings" data-en="⚙️ Settings">⚙️ Settings</h3>
+                    <p data-de="Verwalte deine Privatsphäre-Einstellungen und andere Optionen." data-en="Manage your privacy settings and other options.">Verwalte deine Privatsphäre-Einstellungen und andere Optionen.</p>
+                    <button class="btn btn-primary" style="margin-top: 1rem;" onclick="event.stopPropagation(); showSettings();" data-de="Einstellungen öffnen" data-en="Open Settings">Einstellungen öffnen</button>
+                </div>
+
+                <div class="card" onclick="showRFIDSettings()" style="cursor: pointer;">
+                    <h3 data-de="🏷️ RFID Verknüpfung" data-en="🏷️ RFID Linking">🏷️ RFID Verknüpfung</h3>
+                    <p data-de="Verknüpfe deine RFID-Karte mit deinem Account, um deine Zeiten automatisch zu tracken." data-en="Link your RFID card with your account to automatically track your times.">Verknüpfe deine RFID-Karte mit deinem Account, um deine Zeiten automatisch zu tracken.</p>
+                    <button class="btn btn-primary" style="margin-top: 1rem;" onclick="event.stopPropagation(); showRFIDSettings();" data-de="RFID verknüpfen" data-en="Link RFID">RFID verknüpfen</button>
+                </div>
+
+                <div class="card" id="statisticsCard" style="cursor: pointer;">
+                    <h3 data-de="📊 Statistiken" data-en="📊 Statistics">📊 Statistiken</h3>
+                    <div id="statisticsPreview" style="display: none;">
+                        <div class="statistics-stats">
+                            <div class="mini-stat">
+                                <div class="mini-stat-number" id="personalBest">--:--</div>
+                                <div class="mini-stat-label">Persönliche Bestzeit</div>
+                            </div>
+                            <div class="mini-stat">
+                                <div class="mini-stat-number" id="totalRunsCount">0</div>
+                                <div class="mini-stat-label">Gesamte Läufe</div>
+                            </div>
+                            <div class="mini-stat">
+                                <div class="mini-stat-number" id="rankPosition">-</div>
+                                <div class="mini-stat-label">Ranglisten-Position</div>
+                            </div>
+                        </div>
+                    </div>
+                    <p data-de="Detaillierte Statistiken zu deinen Läufen - beste Zeiten, Verbesserungen und Vergleiche." data-en="Detailed statistics about your runs - best times, improvements and comparisons.">Detaillierte Statistiken zu deinen Läufen - beste Zeiten, Verbesserungen und Vergleiche.</p>
+                    <button class="btn btn-primary" style="margin-top: 1rem;" onclick="event.stopPropagation(); showStatistics();" data-de="Statistiken öffnen" data-en="Open Statistics">Statistiken öffnen</button>
+                </div>
+            </div>
+
+            <!-- User Times Section -->
+            <div class="times-section">
+                <div class="times-header">
+                    <h2 data-de="🏃‍♂️ Meine Zeiten" data-en="🏃‍♂️ My Times">🏃‍♂️ Meine Zeiten</h2>
+                    <p data-de="Deine persönlichen Bestzeiten an allen Standorten" data-en="Your personal best times at all locations">Deine persönlichen Bestzeiten an allen Standorten</p>
+                </div>
+                
+                <!-- Loading State -->
+                <div id="timesLoading" class="times-loading" style="display: none;">
+                    <div class="spinner"></div>
+                    <p data-de="Lade deine Zeiten..." data-en="Loading your times...">Lade deine Zeiten...</p>
+                </div>
+                
+                <!-- Not Linked State -->
+                <div id="timesNotLinked" class="times-not-linked">
+                    <div class="not-linked-content">
+                        <div class="not-linked-icon">🔗</div>
+                        <h3 data-de="RFID noch nicht verknüpft" data-en="RFID not linked yet">RFID noch nicht verknüpft</h3>
+                        <p data-de="Um deine persönlichen Zeiten zu sehen, musst du zuerst deine RFID-Karte mit deinem Account verknüpfen." data-en="To see your personal times, you must first link your RFID card with your account.">Um deine persönlichen Zeiten zu sehen, musst du zuerst deine RFID-Karte mit deinem Account verknüpfen.</p>
+                        <button class="btn btn-primary" onclick="showRFIDSettings()" data-de="🏷️ RFID jetzt verknüpfen" data-en="🏷️ Link RFID now">
+                            🏷️ RFID jetzt verknüpfen
+                        </button>
+                        <div class="link-info">
+                            <h4 data-de="So funktioniert's:" data-en="How it works:">So funktioniert's:</h4>
+                            <ol>
+                                <li data-de="Klicke auf \"RFID jetzt verknüpfen\"" data-en="Click on \"Link RFID now\"">Klicke auf "RFID jetzt verknüpfen"</li>
+                                <li data-de="Scanne den QR-Code auf deiner RFID-Karte" data-en="Scan the QR code on your RFID card">Scanne den QR-Code auf deiner RFID-Karte</li>
+                                <li data-de="Fertig! Deine Zeiten werden automatisch hier angezeigt" data-en="Done! Your times will be displayed here automatically">Fertig! Deine Zeiten werden automatisch hier angezeigt</li>
+                            </ol>
+                        </div>
+                    </div>
+                </div>
+                
+                <!-- Times Display -->
+                <div id="timesDisplay" style="display: none;">
+                    <div class="times-stats">
+                        <div class="stat-card">
+                            <div class="stat-number" id="totalRuns">0</div>
+                            <div class="stat-label" data-de="Gesamte Läufe" data-en="Total Runs">Gesamte Läufe</div>
+                        </div>
+                        <div class="stat-card">
+                            <div class="stat-number" id="bestTime">--:--</div>
+                            <div class="stat-label" data-de="Beste Zeit" data-en="Best Time">Beste Zeit</div>
+                        </div>
+                        <div class="stat-card">
+                            <div class="stat-number" id="locationsCount">0</div>
+                            <div class="stat-label" data-de="Standorte" data-en="Locations">Standorte</div>
+                        </div>
+                        <div class="stat-card">
+                            <div class="stat-number" id="linkedPlayer">--</div>
+                            <div class="stat-label" data-de="Verknüpfter Spieler" data-en="Linked Player">Verknüpfter Spieler</div>
+                        </div>
+                    </div>
+                    
+                    <div class="times-content">
+                        <div class="times-grid" id="userTimesGrid">
+                            <!-- Times will be populated here -->
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Analytics Section -->
+            <div id="analyticsSection" class="analytics-section" style="display: none;">
+                <div class="section-header">
+                    <h2 data-de="📊 Analytics" data-en="📊 Analytics">📊 Analytics</h2>
+                    <p data-de="Detaillierte Analyse deiner Performance und Trends" data-en="Detailed analysis of your performance and trends">Detaillierte Analyse deiner Performance und Trends</p>
+                </div>
+                
+                <!-- Performance Overview -->
+                <div class="analytics-grid">
+                    <div class="analytics-card">
+                        <h3>📈 Performance-Trends</h3>
+                        <div class="trend-stats">
+                            <div class="trend-item">
+                                <span class="trend-label">Diese Woche:</span>
+                                <span class="trend-value" id="avgTimeThisWeekDetail">--:--</span>
+                            </div>
+                            <div class="trend-item">
+                                <span class="trend-label">Letzte Woche:</span>
+                                <span class="trend-value" id="avgTimeLastWeek">--:--</span>
+                            </div>
+                            <div class="trend-item">
+                                <span class="trend-label">Verbesserung:</span>
+                                <span class="trend-value" id="improvementDetail">+0.0%</span>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="analytics-card">
+                        <h3>🏃‍♂️ Aktivitäts-Heatmap</h3>
+                        <div class="activity-stats">
+                            <div class="activity-item">
+                                <span class="activity-label">Heute:</span>
+                                <span class="activity-value" id="runsToday">0 Läufe</span>
+                            </div>
+                            <div class="activity-item">
+                                <span class="activity-label">Diese Woche:</span>
+                                <span class="activity-value" id="runsThisWeekDetail">0 Läufe</span>
+                            </div>
+                            <div class="activity-item">
+                                <span class="activity-label">Durchschnitt/Tag:</span>
+                                <span class="activity-value" id="avgRunsPerDay">0.0</span>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="analytics-card">
+                        <h3>🏆 Standort-Performance</h3>
+                        <div class="location-stats" id="locationPerformance">
+                            <p data-de="Lade Standort-Daten..." data-en="Loading location data...">Lade Standort-Daten...</p>
+                        </div>
+                    </div>
+                    
+                    <div class="analytics-card">
+                        <h3>📅 Monatlicher Fortschritt</h3>
+                        <div class="monthly-stats">
+                            <div class="monthly-item">
+                                <span class="monthly-label">Dieser Monat:</span>
+                                <span class="monthly-value" id="runsThisMonth">0 Läufe</span>
+                            </div>
+                            <div class="monthly-item">
+                                <span class="monthly-label">Letzter Monat:</span>
+                                <span class="monthly-value" id="runsLastMonth">0 Läufe</span>
+                            </div>
+                            <div class="monthly-item">
+                                <span class="monthly-label">Beste Zeit:</span>
+                                <span class="monthly-value" id="bestTimeThisMonth">--:--</span>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Statistics Section -->
+            <div id="statisticsSection" class="statistics-section" style="display: none;">
+                <div class="section-header">
+                    <h2 data-de="📊 Statistiken" data-en="📊 Statistics">📊 Statistiken</h2>
+                    <p data-de="Detaillierte Statistiken zu deinen Läufen und Vergleiche" data-en="Detailed statistics about your runs and comparisons">Detaillierte Statistiken zu deinen Läufen und Vergleiche</p>
+                </div>
+                
+                <!-- Personal Records -->
+                <div class="statistics-grid">
+                    <div class="statistics-card">
+                        <h3>🏆 Persönliche Bestzeiten</h3>
+                        <div class="personal-records" id="personalRecords">
+                            <p data-de="Lade Bestzeiten..." data-en="Loading best times...">Lade Bestzeiten...</p>
+                        </div>
+                    </div>
+                    
+                    <div class="statistics-card">
+                        <h3>📊 Konsistenz-Metriken</h3>
+                        <div class="consistency-stats">
+                            <div class="consistency-item">
+                                <span class="consistency-label">Durchschnittszeit:</span>
+                                <span class="consistency-value" id="averageTime">--:--</span>
+                            </div>
+                            <div class="consistency-item">
+                                <span class="consistency-label">Standardabweichung:</span>
+                                <span class="consistency-value" id="timeDeviation">--:--</span>
+                            </div>
+                            <div class="consistency-item">
+                                <span class="consistency-label">Konsistenz-Score:</span>
+                                <span class="consistency-value" id="consistencyScore">0%</span>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="statistics-card">
+                        <h3>🏅 Ranglisten-Positionen</h3>
+                        <div class="ranking-stats" id="rankingStats">
+                            <p data-de="Lade Ranglisten..." data-en="Loading rankings...">Lade Ranglisten...</p>
+                        </div>
+                    </div>
+                    
+                    <div class="statistics-card">
+                        <h3>📈 Fortschritt-Übersicht</h3>
+                        <div class="progress-stats">
+                            <div class="progress-item">
+                                <span class="progress-label">Gesamte Läufe:</span>
+                                <span class="progress-value" id="totalRunsStats">0</span>
+                            </div>
+                            <div class="progress-item">
+                                <span class="progress-label">Aktive Tage:</span>
+                                <span class="progress-value" id="activeDays">0</span>
+                            </div>
+                            <div class="progress-item">
+                                <span class="progress-label">Standorte besucht:</span>
+                                <span class="progress-value" id="locationsVisited">0</span>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Achievements Section -->
+            <div class="achievements-section">
+                <div class="achievements-header">
+                    <h2 data-de="🏆 Meine Achievements" data-en="🏆 My Achievements">🏆 Meine Achievements</h2>
+                    <p data-de="Sammele Punkte und erreiche neue Meilensteine!" data-en="Collect points and reach new milestones!">Sammele Punkte und erreiche neue Meilensteine!</p>
+                </div>
+                
+                <!-- Achievement Stats -->
+                <div class="achievement-stats" id="achievementStats" style="display: none;">
+                    <div class="stat-card achievement-stat">
+                        <div class="stat-number" id="totalPoints">0</div>
+                        <div class="stat-label" data-de="Gesamtpunkte" data-en="Total Points">Gesamtpunkte</div>
+                    </div>
+                    <div class="stat-card achievement-stat">
+                        <div class="stat-number" id="completedAchievements">0</div>
+                        <div class="stat-label" data-de="Abgeschlossen" data-en="Completed">Abgeschlossen</div>
+                    </div>
+                    <div class="stat-card achievement-stat">
+                        <div class="stat-number" id="achievementsToday">0</div>
+                        <div class="stat-label" data-de="Heute erreicht" data-en="Achieved Today">Heute erreicht</div>
+                    </div>
+                    <div class="stat-card achievement-stat">
+                        <div class="stat-number" id="completionPercentage">0%</div>
+                        <div class="stat-label" data-de="Fortschritt" data-en="Progress">Fortschritt</div>
+                    </div>
+                </div>
+                
+                <!-- Achievement Categories -->
+                <div class="achievement-categories" id="achievementCategories" style="display: none;">
+                    <div class="category-tabs">
+                        <button class="category-tab active" onclick="showAchievementCategory('all')" data-category="all" data-de="Alle" data-en="All">Alle</button>
+                        <button class="category-tab" onclick="showAchievementCategory('consistency')" data-category="consistency" data-de="Konsistenz" data-en="Consistency">Konsistenz</button>
+                        <button class="category-tab" onclick="showAchievementCategory('improvement')" data-category="improvement" data-de="Verbesserung" data-en="Improvement">Verbesserung</button>
+                        <button class="category-tab" onclick="showAchievementCategory('seasonal')" data-category="seasonal" data-de="Saisonal" data-en="Seasonal">Saisonal</button>
+                        <button class="category-tab" onclick="showAchievementCategory('monthly')" data-category="monthly" data-de="Monatlich" data-en="Monthly">Monatlich</button>
+                    </div>
+                    
+                    <div class="achievements-grid" id="achievementsGrid">
+                        <!-- Achievements will be populated here -->
+                    </div>
+                </div>
+                
+                <!-- Achievement Loading State -->
+                <div id="achievementsLoading" class="achievements-loading" style="display: none;">
+                    <div class="spinner"></div>
+                    <p data-de="Lade deine Achievements..." data-en="Loading your achievements...">Lade deine Achievements...</p>
+                </div>
+                
+                <!-- Achievement Not Available State -->
+                <div id="achievementsNotAvailable" class="achievements-not-available" style="display: none;">
+                    <div class="not-available-content">
+                        <div class="not-available-icon">🏆</div>
+                        <h3 data-de="Achievements noch nicht verfügbar" data-en="Achievements not available yet">Achievements noch nicht verfügbar</h3>
+                        <p data-de="Um Achievements zu sammeln, musst du zuerst deine RFID-Karte mit deinem Account verknüpfen und einige Läufe absolvieren." data-en="To collect achievements, you must first link your RFID card with your account and complete some runs.">Um Achievements zu sammeln, musst du zuerst deine RFID-Karte mit deinem Account verknüpfen und einige Läufe absolvieren.</p>
+                        <button class="btn btn-primary" onclick="showRFIDSettings()" data-de="🏷️ RFID jetzt verknüpfen" data-en="🏷️ Link RFID now">
+                            🏷️ RFID jetzt verknüpfen
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- RFID Settings Modal -->
+    <div id="rfidModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h2 class="modal-title" data-de="📱 RFID QR-Code Scanner" data-en="📱 RFID QR Code Scanner">📱 RFID QR-Code Scanner</h2>
+                <span class="close" onclick="closeModal('rfidModal')">&times;</span>
+            </div>
+            <div id="rfidMessage"></div>
+            
+            <!-- QR Scanner Step -->
+            <div id="qrScannerStep">
+                <p style="color: #8892b0; margin-bottom: 1.5rem; text-align: center;" data-de="Scanne den QR-Code auf deiner RFID-Karte, um sie mit deinem Account zu verknüpfen." data-en="Scan the QR code on your RFID card to link it with your account.">
+                    Scanne den QR-Code auf deiner RFID-Karte, um sie mit deinem Account zu verknüpfen.
+                </p>
+                
+                <!-- Camera Preview -->
+                <div id="cameraContainer" style="display: none;">
+                    <video id="qrVideo" style="width: 100%; max-width: 400px; border-radius: 0.75rem; margin: 0 auto; display: block;"></video>
+                    <canvas id="qrCanvas" style="display: none;"></canvas>
+                </div>
+                
+                <!-- Scanner Controls -->
+                <div style="text-align: center; margin: 1.5rem 0;">
+                    <button class="btn btn-primary" onclick="startQRScanner()" id="startScanBtn" data-de="📷 Kamera starten" data-en="📷 Start Camera">
+                        📷 Kamera starten
+                    </button>
+                    <button class="btn btn-secondary" onclick="stopQRScanner()" id="stopScanBtn" style="display: none;" data-de="🛑 Scanner stoppen" data-en="🛑 Stop Scanner">
+                        🛑 Scanner stoppen
+                    </button>
+                </div>
+                
+                <!-- Manual Input Fallback -->
+                <div style="border-top: 1px solid #334155; padding-top: 1.5rem; margin-top: 1.5rem;">
+                    <p style="color: #8892b0; text-align: center; margin-bottom: 1rem; font-size: 0.9rem;" data-de="Kamera funktioniert nicht? RFID UID manuell eingeben:" data-en="Camera not working? Enter RFID UID manually:">
+                        Kamera funktioniert nicht? RFID UID manuell eingeben:
+                    </p>
+                    <div class="form-group">
+                        <input type="text" id="manualRfidInput" class="form-input" placeholder="z.B. aaaaaa, FFFFFF oder FF:FF:FF:FF" style="text-align: center; font-family: monospace;" data-de="z.B. aaaaaa, FFFFFF oder FF:FF:FF:FF" data-en="e.g. aaaaaa, FFFFFF or FF:FF:FF:FF">
+                    </div>
+                    <button class="btn btn-secondary" onclick="linkManualRfid()" style="width: 100%;" data-de="Manuell verknüpfen" data-en="Link Manually">
+                        Manuell verknüpfen
+                    </button>
+                </div>
+
+                <!-- Create New Player Section -->
+                <div id="createPlayerSection" style="border-top: 1px solid #334155; padding-top: 1.5rem; margin-top: 1.5rem;">
+                    <p style="color: #8892b0; text-align: center; margin-bottom: 1rem; font-size: 0.9rem;" data-de="Neuen Spieler mit RFID erstellen:" data-en="Create new player with RFID:">
+                        Neuen Spieler mit RFID erstellen:
+                    </p>
+                    
+                    <div class="form-group">
+                        <label for="playerFirstname" style="color: #8892b0; font-size: 0.9rem; margin-bottom: 0.5rem; display: block;" data-de="Vorname:" data-en="First Name:">Vorname:</label>
+                        <input type="text" id="playerFirstname" class="form-input" placeholder="Max" style="text-align: center;">
+                    </div>
+                    
+                    <div class="form-group">
+                        <label for="playerLastname" style="color: #8892b0; font-size: 0.9rem; margin-bottom: 0.5rem; display: block;" data-de="Nachname:" data-en="Last Name:">Nachname:</label>
+                        <input type="text" id="playerLastname" class="form-input" placeholder="Mustermann" style="text-align: center;">
+                    </div>
+                    
+                    <div class="form-group">
+                        <label for="playerBirthdate" style="color: #8892b0; font-size: 0.9rem; margin-bottom: 0.5rem; display: block;" data-de="Geburtsdatum:" data-en="Birth Date:">Geburtsdatum:</label>
+                        <input type="date" id="playerBirthdate" class="form-input" style="text-align: center;">
+                    </div>
+                    
+                    <!-- AGB Section -->
+                    <div class="agb-section" style="background: #1e293b; border: 1px solid #334155; border-radius: 8px; padding: 15px; margin: 15px 0;">
+                        <div class="agb-checkbox" style="display: flex; align-items: flex-start; gap: 10px; margin-bottom: 10px;">
+                            <input type="checkbox" id="agbAccepted" name="agbAccepted" required style="width: auto; margin: 0; margin-top: 3px;">
+                            <label for="agbAccepted" style="color: #e2e8f0; font-size: 0.85rem; line-height: 1.4; margin: 0; font-weight: normal;">
+                                Ich habe die <a href="/agb.html" target="_blank" style="color: #00d4ff; text-decoration: none; font-weight: bold;">Allgemeinen Geschäftsbedingungen</a> 
+                                gelesen und stimme zu, dass mein Name und meine Laufzeiten im öffentlichen Leaderboard angezeigt werden.
+                            </label>
+                        </div>
+                        <div class="agb-warning" style="color: #fbbf24; font-size: 0.8rem; margin-top: 10px;">
+                            ⚠️ <strong>Wichtig:</strong> Ohne Zustimmung zu den AGB können Sie das System nutzen, 
+                            aber Ihre Zeiten werden nicht im öffentlichen Leaderboard angezeigt.
+                        </div>
+                    </div>
+                    
+                    <button class="btn btn-primary" onclick="createRfidPlayerRecord()" style="width: 100%;" data-de="Spieler erstellen" data-en="Create Player">
+                        Spieler erstellen
+                    </button>
+                </div>
+
+                <!-- Scanning Status -->
+                <div id="scanningStatus" style="display: none; text-align: center; color: #00d4ff; margin-top: 1rem;">
+                    <div class="spinner" style="width: 20px; height: 20px; margin: 0 auto 0.5rem;"></div>
+                    <span data-de="Suche nach QR-Code..." data-en="Searching for QR code...">Suche nach QR-Code...</span>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Settings Modal -->
+    <div id="settingsModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h2 class="modal-title" data-de="⚙️ Einstellungen" data-en="⚙️ Settings">⚙️ Einstellungen</h2>
+                <span class="close" onclick="closeModal('settingsModal')">&times;</span>
+            </div>
+            
+            <div class="settings-content">
+                <div class="setting-item">
+                    <div class="setting-info">
+                        <h3 data-de="🏆 Leaderboard Sichtbarkeit" data-en="🏆 Leaderboard Visibility">🏆 Leaderboard Sichtbarkeit</h3>
+                        <p data-de="Bestimme, ob deine Zeiten im globalen Leaderboard angezeigt werden sollen." data-en="Determine whether your times should be displayed in the global leaderboard.">Bestimme, ob deine Zeiten im globalen Leaderboard angezeigt werden sollen.</p>
+                    </div>
+                    <div class="setting-control">
+                        <label class="toggle-switch">
+                            <input type="checkbox" id="showInLeaderboard" onchange="updateLeaderboardSetting()">
+                            <span class="toggle-slider"></span>
+                        </label>
+                    </div>
+                </div>
+                
+                <div class="setting-description">
+                    <p style="color: #8892b0; font-size: 0.9rem; margin-top: 1rem; padding: 1rem; background: #1e293b; border-radius: 0.5rem;" data-de="<strong>Hinweis:</strong> Wenn diese Option deaktiviert ist, werden deine Zeiten nur in deinem persönlichen Dashboard angezeigt, aber nicht im öffentlichen Leaderboard. Du kannst diese Einstellung jederzeit ändern." data-en="<strong>Note:</strong> If this option is disabled, your times will only be displayed in your personal dashboard, but not in the public leaderboard. You can change this setting at any time.">
+                        <strong>Hinweis:</strong> Wenn diese Option deaktiviert ist, werden deine Zeiten nur in deinem persönlichen Dashboard angezeigt, aber nicht im öffentlichen Leaderboard. Du kannst diese Einstellung jederzeit ändern.
+                    </p>
+                </div>
+                
+                <div class="settings-actions">
+                    <button class="btn btn-primary" onclick="saveSettings()" data-de="Einstellungen speichern" data-en="Save Settings">Einstellungen speichern</button>
+                    <button class="btn btn-secondary" onclick="closeModal('settingsModal')" data-de="Abbrechen" data-en="Cancel">Abbrechen</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-content">
+            <div class="footer-links">
+                <a href="/impressum.html" class="footer-link" data-de="Impressum" data-en="Imprint">Impressum</a>
+                <a href="/datenschutz.html" class="footer-link" data-de="Datenschutz" data-en="Privacy">Datenschutz</a>
+                <button id="cookie-settings-footer" class="footer-link cookie-settings-btn" data-de="Cookie-Einstellungen" data-en="Cookie Settings">Cookie-Einstellungen</button>
+            </div>
+            <div class="footer-text">
+                <p data-de="&copy; 2024 NinjaCross. Alle Rechte vorbehalten." data-en="&copy; 2024 NinjaCross. All rights reserved.">&copy; 2024 NinjaCross. Alle Rechte vorbehalten.</p>
+            </div>
+        </div>
+    </footer>
+
+    <script src="/js/cookie-consent.js"></script>
+    <script src="/js/dashboard.js?v=1.6"></script>
+    
+    <script>
+        // PWA Installation
+        let deferredPrompt;
+        
+        // Listen for PWA install prompt
+        window.addEventListener('beforeinstallprompt', (e) => {
+            e.preventDefault();
+            deferredPrompt = e;
+            const pwaButton = document.getElementById('pwaButton');
+            if (pwaButton) {
+                pwaButton.style.display = 'inline-block';
+            }
+        });
+
+        // Install PWA
+        async function installPWA() {
+            if (deferredPrompt) {
+                deferredPrompt.prompt();
+                const { outcome } = await deferredPrompt.userChoice;
+                console.log(`PWA install outcome: ${outcome}`);
+                deferredPrompt = null;
+                
+                const pwaButton = document.getElementById('pwaButton');
+                if (pwaButton) {
+                    pwaButton.style.display = 'none';
+                }
+            } else if (isIOS()) {
+                // Show iOS installation instructions
+                showIOSPWAHint();
+            }
+        }
+
+        // Check if PWA is already installed
+        window.addEventListener('appinstalled', () => {
+            console.log('PWA was installed');
+            const pwaButton = document.getElementById('pwaButton');
+            if (pwaButton) {
+                pwaButton.style.display = 'none';
+            }
+        });
+
+        // Initialize dashboard when page loads
+        document.addEventListener('DOMContentLoaded', function () {
+            // Show PWA hint for iOS users
+            if (isIOS() && !isPWAInstalled()) {
+                setTimeout(showIOSPWAHint, 2000); // Show after 2 seconds
+            }
+        });
+    </script>
+</body>
+</html>
diff --git a/public/datenschutz.html b/public/datenschutz.html
new file mode 100644
index 0000000..e929249
--- /dev/null
+++ b/public/datenschutz.html
@@ -0,0 +1,362 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Datenschutzerklärung - NinjaCross</title>
+    <link rel="icon" type="image/x-icon" href="/pictures/favicon.ico">
+    <link rel="stylesheet" href="/css/leaderboard.css">
+    <style>
+        .legal-container {
+            max-width: 1000px;
+            margin: 0 auto;
+            padding: 2rem;
+            min-height: 100vh;
+        }
+
+        .legal-header {
+            text-align: center;
+            margin-bottom: 3rem;
+        }
+
+        .legal-title {
+            font-size: 3.5rem;
+            font-weight: 700;
+            background: linear-gradient(135deg, #00d4ff, #ff6b35, #ffd700);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            margin-bottom: 0.5rem;
+            letter-spacing: -0.02em;
+        }
+
+        .legal-subtitle {
+            font-size: 1.2rem;
+            color: #8892b0;
+            font-weight: 300;
+        }
+
+        .legal-content {
+            background: rgba(30, 41, 59, 0.8);
+            backdrop-filter: blur(20px);
+            border: 1px solid rgba(51, 65, 85, 0.3);
+            border-radius: 20px;
+            padding: 3rem;
+            box-shadow: 0 20px 40px rgba(0, 0, 0, 0.3);
+        }
+
+        .section {
+            margin-bottom: 2.5rem;
+        }
+
+        .section h2 {
+            color: #00d4ff;
+            font-size: 1.8rem;
+            margin-bottom: 1rem;
+            border-bottom: 2px solid #334155;
+            padding-bottom: 0.5rem;
+            font-weight: 600;
+        }
+
+        .section h3 {
+            color: #ff6b35;
+            font-size: 1.3rem;
+            margin: 1.5rem 0 0.8rem 0;
+            font-weight: 500;
+        }
+
+        .section p, .section li {
+            margin-bottom: 0.8rem;
+            color: #e2e8f0;
+            line-height: 1.6;
+        }
+
+        .section ul, .section ol {
+            margin-left: 1.5rem;
+        }
+
+        .contact-info {
+            background: rgba(0, 212, 255, 0.1);
+            border: 1px solid rgba(0, 212, 255, 0.3);
+            padding: 1.5rem;
+            border-radius: 12px;
+            margin: 1rem 0;
+        }
+
+        .contact-info p {
+            margin-bottom: 0.5rem;
+        }
+
+        .contact-info strong {
+            color: #00d4ff;
+        }
+
+        .back-button {
+            display: inline-flex;
+            align-items: center;
+            gap: 0.5rem;
+            background: linear-gradient(135deg, #00d4ff, #0099cc);
+            color: white;
+            padding: 12px 24px;
+            text-decoration: none;
+            border-radius: 12px;
+            margin-top: 2rem;
+            font-weight: 600;
+            transition: all 0.3s ease;
+            box-shadow: 0 4px 15px rgba(0, 212, 255, 0.3);
+        }
+
+        .back-button:hover {
+            background: linear-gradient(135deg, #0099cc, #007aa3);
+            transform: translateY(-2px);
+            box-shadow: 0 8px 25px rgba(0, 212, 255, 0.4);
+        }
+
+        .highlight-box {
+            background: rgba(255, 107, 53, 0.1);
+            border: 1px solid rgba(255, 107, 53, 0.3);
+            padding: 1.5rem;
+            border-radius: 12px;
+            margin: 1.5rem 0;
+        }
+
+        .highlight-box h3 {
+            color: #ff6b35;
+            margin-top: 0;
+        }
+
+        .highlight-box p {
+            color: #e2e8f0;
+            margin: 0;
+        }
+
+        .cookie-table {
+            width: 100%;
+            border-collapse: collapse;
+            margin: 1.5rem 0;
+            background: rgba(30, 41, 59, 0.5);
+            border-radius: 12px;
+            overflow: hidden;
+        }
+
+        .cookie-table th, .cookie-table td {
+            border: 1px solid rgba(51, 65, 85, 0.3);
+            padding: 1rem;
+            text-align: left;
+        }
+
+        .cookie-table th {
+            background: rgba(0, 212, 255, 0.1);
+            font-weight: 600;
+            color: #00d4ff;
+        }
+
+        .cookie-table td {
+            color: #e2e8f0;
+        }
+
+        @media (max-width: 768px) {
+            .legal-container {
+                padding: 1rem;
+            }
+            
+            .legal-content {
+                padding: 1.5rem;
+            }
+            
+            .legal-title {
+                font-size: 2.5rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="legal-container">
+        <div class="legal-header">
+            <h1 class="legal-title">🔒 Datenschutzerklärung</h1>
+            <p class="legal-subtitle">NinjaCross - Speedrun Arena</p>
+        </div>
+        
+        <div class="legal-content">
+            <div class="section">
+                <h2>1. Datenschutz auf einen Blick</h2>
+                <h3>Allgemeine Hinweise</h3>
+                <p>Die folgenden Hinweise geben einen einfachen Überblick darüber, was mit Ihren personenbezogenen Daten passiert, wenn Sie diese Website besuchen. Personenbezogene Daten sind alle Daten, mit denen Sie persönlich identifiziert werden können. Ausführliche Informationen zum Thema Datenschutz entnehmen Sie unserer unter diesem Text aufgeführten Datenschutzerklärung.</p>
+            </div>
+
+            <div class="section">
+                <h2>2. Datenerfassung auf dieser Website</h2>
+                <h3>Wer ist verantwortlich für die Datenerfassung auf dieser Website?</h3>
+                <p>Die Datenverarbeitung auf dieser Website erfolgt durch den Websitebetreiber. Dessen Kontaktdaten können Sie dem Abschnitt „Hinweis zur Verantwortlichen Stelle" in dieser Datenschutzerklärung entnehmen.</p>
+
+                <h3>Wie erfassen wir Ihre Daten?</h3>
+                <p>Ihre Daten werden zum einen dadurch erhoben, dass Sie uns diese mitteilen. Hierbei kann es sich z. B. um Daten handeln, die Sie in ein Kontaktformular eingeben.</p>
+                <p>Andere Daten werden automatisch oder nach Ihrer Einwilligung beim Besuch der Website durch unsere IT-Systeme erfasst. Das sind vor allem technische Daten (z. B. Internetbrowser, Betriebssystem oder Uhrzeit des Seitenaufrufs). Die Erfassung dieser Daten erfolgt automatisch, sobald Sie diese Website betreten.</p>
+
+                <h3>Wofür nutzen wir Ihre Daten?</h3>
+                <p>Ein Teil der Daten wird erhoben, um eine fehlerfreie Bereitstellung der Website zu gewährleisten. Andere Daten können zur Analyse Ihres Nutzerverhaltens verwendet werden.</p>
+
+                <h3>Welche Rechte haben Sie bezüglich Ihrer Daten?</h3>
+                <p>Sie haben jederzeit das Recht, unentgeltlich Auskunft über Herkunft, Empfänger und Zweck Ihrer gespeicherten personenbezogenen Daten zu erhalten. Sie haben außerdem ein Recht, die Berichtigung oder Löschung dieser Daten zu verlangen. Wenn Sie eine Einwilligung zur Datenverarbeitung erteilt haben, können Sie diese Einwilligung jederzeit für die Zukunft widerrufen. Außerdem haben Sie das Recht, unter bestimmten Umständen die Einschränkung der Verarbeitung Ihrer personenbezogenen Daten zu verlangen. Des Weiteren steht Ihnen ein Beschwerderecht bei der zuständigen Aufsichtsbehörde zu.</p>
+            </div>
+
+            <div class="section">
+                <h2>3. Hosting</h2>
+                <p>Wir hosten die Inhalte unserer Website bei folgendem Anbieter:</p>
+                <div class="contact-info">
+                    <p><strong>Serverstandort:</strong> Deutschland<br>
+                    <strong>Anbieter:</strong> [Ihr Hosting-Anbieter]<br>
+                    <strong>Datenschutz:</strong> <a href="#" target="_blank" rel="noopener">Datenschutzerklärung des Anbieters</a></p>
+                </div>
+            </div>
+
+            <div class="section">
+                <h2>4. Allgemeine Hinweise und Pflichtinformationen</h2>
+                <h3>Datenschutz</h3>
+                <p>Die Betreiber dieser Seiten nehmen den Schutz Ihrer persönlichen Daten sehr ernst. Wir behandeln Ihre personenbezogenen Daten vertraulich und entsprechend den gesetzlichen Datenschutzvorschriften sowie dieser Datenschutzerklärung.</p>
+
+                <h3>Hinweis zur verantwortlichen Stelle</h3>
+                <p>Die verantwortliche Stelle für die Datenverarbeitung auf dieser Website ist:</p>
+                <div class="contact-info">
+                    <p>Max Mustermann<br>
+                    Musterstraße 123<br>
+                    12345 Musterstadt<br>
+                    Deutschland</p>
+                    <p>Telefon: +49 (0) 123 456789<br>
+                    E-Mail: info@ninjacross.de</p>
+                </div>
+
+                <h3>Speicherdauer</h3>
+                <p>Soweit innerhalb dieser Datenschutzerklärung keine speziellere Speicherdauer genannt wurde, verbleiben Ihre personenbezogenen Daten bei uns, bis der Zweck für die Datenverarbeitung entfällt. Wenn Sie ein berechtigtes Löschersuchen geltend machen oder eine Einwilligung zur Datenverarbeitung widerrufen, werden Ihre Daten gelöscht, sofern wir keine anderen rechtlich zulässigen Gründe für die Speicherung Ihrer personenbezogenen Daten haben (z. B. steuer- oder handelsrechtliche Aufbewahrungsfristen); im letztgenannten Fall erfolgt die Löschung nach Fortfall dieser Gründe.</p>
+            </div>
+
+            <div class="section">
+                <h2>5. Datenerfassung auf dieser Website</h2>
+                <h3>Cookies</h3>
+                <p>Unsere Internetseiten verwenden so genannte „Cookies". Cookies sind kleine Textdateien und richten auf Ihrem Endgerät keinen Schaden an. Sie werden entweder vorübergehend für die Dauer einer Sitzung (Session-Cookies) oder dauerhaft (dauerhafte Cookies) auf Ihrem Endgerät gespeichert. Session-Cookies werden nach Ende Ihres Besuchs automatisch gelöscht. Von dauerhaften Cookies bleibt eine Teil auf Ihrem Endgerät gespeichert, bis Sie diese selbst löschen oder eine automatische Löschung durch Ihren Webbrowser erfolgt.</p>
+
+                <p>Teilweise können auch Cookies von Drittanbietern auf Ihrem Endgerät gespeichert werden, wenn Sie unsere Seite betreten (Third-Party-Cookies). Diese ermöglichen uns oder Ihnen die Nutzung bestimmter Dienstleistungen des Drittanbieters (z. B. Cookies zur Abwicklung von Zahlungsdienstleistungen).</p>
+
+                <h3>Cookie-Übersicht</h3>
+                <table class="cookie-table">
+                    <thead>
+                        <tr>
+                            <th>Cookie-Name</th>
+                            <th>Zweck</th>
+                            <th>Speicherdauer</th>
+                            <th>Typ</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        <tr>
+                            <td>session</td>
+                            <td>Authentifizierung und Session-Management</td>
+                            <td>24 Stunden</td>
+                            <td>Notwendig</td>
+                        </tr>
+                        <tr>
+                            <td>supabase.auth.token</td>
+                            <td>Benutzer-Authentifizierung (Supabase)</td>
+                            <td>1 Jahr</td>
+                            <td>Funktional</td>
+                        </tr>
+                        <tr>
+                            <td>page_views</td>
+                            <td>Seitenaufruf-Statistiken</td>
+                            <td>30 Tage</td>
+                            <td>Statistik</td>
+                        </tr>
+                    </tbody>
+                </table>
+
+                <h3>Server-Log-Dateien</h3>
+                <p>Der Provider der Seiten erhebt und speichert automatisch Informationen in so genannten Server-Log-Dateien, die Ihr Browser automatisch an uns übermittelt. Dies sind:</p>
+                <ul>
+                    <li>Browsertyp und Browserversion</li>
+                    <li>verwendetes Betriebssystem</li>
+                    <li>Referrer URL</li>
+                    <li>Hostname des zugreifenden Rechners</li>
+                    <li>Uhrzeit der Serveranfrage</li>
+                    <li>IP-Adresse</li>
+                </ul>
+                <p>Eine Zusammenführung dieser Daten mit anderen Datenquellen wird nicht vorgenommen. Die Erfassung dieser Daten erfolgt auf Grundlage von Art. 6 Abs. 1 lit. f DSGVO.</p>
+            </div>
+
+            <div class="section">
+                <h2>6. Plugins und Tools</h2>
+                <h3>Google OAuth</h3>
+                <p>Diese Website nutzt Google OAuth für die Benutzeranmeldung. Anbieter ist die Google Ireland Limited („Google"), Gordon House, Barrow Street, Dublin 4, Irland.</p>
+                <p>Wenn Sie sich über Google anmelden, werden Ihre Daten an Google übertragen. Die Nutzung von Google OAuth erfolgt auf Grundlage von Art. 6 Abs. 1 lit. f DSGVO. Weitere Informationen finden Sie in der <a href="https://policies.google.com/privacy" target="_blank" rel="noopener">Datenschutzerklärung von Google</a>.</p>
+
+                <h3>Supabase</h3>
+                <p>Diese Website nutzt Supabase für die Benutzerauthentifizierung und Datenbankdienste. Anbieter ist Supabase Inc., 970 Toa Payoh North #07-04, Singapore 318992.</p>
+                <p>Weitere Informationen finden Sie in der <a href="https://supabase.com/privacy" target="_blank" rel="noopener">Datenschutzerklärung von Supabase</a>.</p>
+            </div>
+
+            <div class="section">
+                <h2>7. Ihre Rechte</h2>
+                <h3>Recht auf Auskunft</h3>
+                <p>Sie haben das Recht, jederzeit Auskunft über die von uns über Sie gespeicherten personenbezogenen Daten zu verlangen.</p>
+
+                <h3>Recht auf Berichtigung</h3>
+                <p>Sie haben das Recht, die Berichtigung unrichtiger oder die Vervollständigung unvollständiger Daten zu verlangen.</p>
+
+                <h3>Recht auf Löschung</h3>
+                <p>Sie haben das Recht, die Löschung Ihrer personenbezogenen Daten zu verlangen.</p>
+
+                <h3>Recht auf Einschränkung der Verarbeitung</h3>
+                <p>Sie haben das Recht, die Einschränkung der Verarbeitung Ihrer personenbezogenen Daten zu verlangen.</p>
+
+                <h3>Recht auf Datenübertragbarkeit</h3>
+                <p>Sie haben das Recht, die Sie betreffenden personenbezogenen Daten in einem strukturierten, gängigen und maschinenlesbaren Format zu erhalten.</p>
+
+                <h3>Widerruf Ihrer Einwilligung zur Datenverarbeitung</h3>
+                <p>Viele Datenverarbeitungsvorgänge sind nur mit Ihrer ausdrücklichen Einwilligung möglich. Sie können eine bereits erteilte Einwilligung jederzeit widerrufen. Die Rechtmäßigkeit der bis zum Widerruf erfolgten Datenverarbeitung bleibt vom Widerruf unberührt.</p>
+
+                <h3>Recht auf Beschwerde bei der zuständigen Aufsichtsbehörde</h3>
+                <p>Im Falle von Verstößen gegen die DSGVO steht den Betroffenen ein Beschwerderecht bei einer Aufsichtsbehörde, insbesondere in dem Mitgliedstaat ihres gewöhnlichen Aufenthalts, ihres Arbeitsplatzes oder des Orts des mutmaßlichen Verstoßes zu. Das Beschwerderecht besteht unbeschadet anderweitiger verwaltungsrechtlicher oder gerichtlicher Rechtsbehelfe.</p>
+            </div>
+
+            <div class="section">
+                <h2>8. Kontakt</h2>
+                <p>Bei Fragen zum Datenschutz wenden Sie sich bitte an:</p>
+                <div class="contact-info">
+                    <p>E-Mail: datenschutz@ninjacross.de<br>
+                    Telefon: +49 (0) 123 456789</p>
+                </div>
+            </div>
+
+            <a href="/" class="back-button">← Zurück zur Startseite</a>
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-content">
+            <div class="footer-links">
+                <a href="/impressum.html" class="footer-link">Impressum</a>
+                <a href="/datenschutz.html" class="footer-link">Datenschutz</a>
+                <button id="cookie-settings-footer" class="footer-link cookie-settings-btn">Cookie-Einstellungen</button>
+            </div>
+            <div class="footer-text">
+                <p>&copy; 2024 NinjaCross. Alle Rechte vorbehalten.</p>
+            </div>
+        </div>
+    </footer>
+
+    <script src="/js/cookie-consent.js"></script>
+    <script>
+        // Add cookie settings button functionality
+        document.addEventListener('DOMContentLoaded', function() {
+            const cookieSettingsBtn = document.getElementById('cookie-settings-footer');
+            if (cookieSettingsBtn) {
+                cookieSettingsBtn.addEventListener('click', function() {
+                    if (window.cookieConsent) {
+                        window.cookieConsent.resetConsent();
+                    }
+                });
+            }
+        });
+    </script>
+</body>
+</html>
diff --git a/public/email-templates/EMAIL-COMPATIBILITY-GUIDE.md b/public/email-templates/EMAIL-COMPATIBILITY-GUIDE.md
new file mode 100644
index 0000000..5c73f8f
--- /dev/null
+++ b/public/email-templates/EMAIL-COMPATIBILITY-GUIDE.md
@@ -0,0 +1,181 @@
+# E-Mail-Client-Kompatibilität Guide
+
+## 🚨 Problem: Farben sehen in E-Mail-Clients komisch aus
+
+E-Mail-Clients sind sehr restriktiv mit CSS und unterstützen oft keine modernen Features. Hier sind die Lösungen:
+
+## ❌ Was E-Mail-Clients NICHT unterstützen:
+
+### CSS-Features
+- **Gradients** (`linear-gradient`, `radial-gradient`)
+- **Backdrop-Filter** (`backdrop-filter: blur()`)
+- **Box-Shadow** (komplexe Schatten)
+- **Transforms** (`transform: translateY()`)
+- **Custom Fonts** (Google Fonts, Inter)
+- **Flexbox/Grid** (begrenzte Unterstützung)
+- **CSS-Variablen** (`--custom-property`)
+
+### Farben
+- **Transparente Hintergründe** (`rgba()` mit Alpha)
+- **Komplexe Farbverläufe**
+- **Moderne CSS-Farben** (HSL, etc.)
+
+## ✅ E-Mail-Client-kompatible Alternativen:
+
+### 1. Einfache Hintergrundfarben
+```css
+/* ❌ Nicht kompatibel */
+background: linear-gradient(135deg, #00d4ff, #0891b2);
+
+/* ✅ Kompatibel */
+background-color: #00d4ff;
+```
+
+### 2. Einfache Borders
+```css
+/* ❌ Nicht kompatibel */
+border: 1px solid rgba(51, 65, 85, 0.3);
+
+/* ✅ Kompatibel */
+border: 1px solid #334155;
+```
+
+### 3. Standard-Fonts
+```css
+/* ❌ Nicht kompatibel */
+font-family: 'Inter', sans-serif;
+
+/* ✅ Kompatibel */
+font-family: Arial, sans-serif;
+```
+
+### 4. Einfache Container
+```css
+/* ❌ Nicht kompatibel */
+background: rgba(30, 41, 59, 0.95);
+backdrop-filter: blur(20px);
+
+/* ✅ Kompatibel */
+background-color: #1e293b;
+```
+
+## 🎨 Optimierte Farbpalette für E-Mail:
+
+### Hauptfarben
+- **Hintergrund:** `#0a0a0f` (Dunkelblau)
+- **Container:** `#1e293b` (Dunkelgrau)
+- **Akzent:** `#00d4ff` (Neon-Blau)
+- **Text:** `#ffffff` (Weiß)
+- **Sekundärtext:** `#cbd5e1` (Hellgrau)
+
+### Status-Farben
+- **Erfolg:** `#22c55e` (Grün)
+- **Warnung:** `#f59e0b` (Orange)
+- **Fehler:** `#ef4444` (Rot)
+- **Info:** `#00d4ff` (Blau)
+
+## 📱 Responsive Design für E-Mail:
+
+### Media Queries
+```css
+@media (max-width: 600px) {
+    .email-container {
+        margin: 0 10px;
+    }
+    
+    .email-content {
+        padding: 20px 15px;
+    }
+}
+```
+
+### Mobile-First Approach
+- **Max-Width:** 600px für Container
+- **Padding:** Reduziert auf mobilen Geräten
+- **Schriftgrößen:** Angepasst für kleine Bildschirme
+
+## 🔧 Template-Optimierungen:
+
+### 1. Inline-CSS verwenden
+```html
+<div style="background-color: #1e293b; padding: 20px;">
+    Inhalt
+</div>
+```
+
+### 2. Tabellen-Layout für komplexe Strukturen
+```html
+<table width="100%" cellpadding="0" cellspacing="0">
+    <tr>
+        <td style="padding: 20px;">
+            Inhalt
+        </td>
+    </tr>
+</table>
+```
+
+### 3. Fallback-Farben definieren
+```css
+background-color: #00d4ff; /* Fallback */
+background: linear-gradient(135deg, #00d4ff, #0891b2); /* Modern */
+```
+
+## 📊 E-Mail-Client-Test-Matrix:
+
+| Client | Gradients | Backdrop-Filter | Box-Shadow | Custom Fonts |
+|--------|-----------|-----------------|------------|--------------|
+| Gmail | ❌ | ❌ | ❌ | ❌ |
+| Outlook | ❌ | ❌ | ❌ | ❌ |
+| Apple Mail | ✅ | ❌ | ✅ | ✅ |
+| Thunderbird | ❌ | ❌ | ❌ | ❌ |
+| Yahoo Mail | ❌ | ❌ | ❌ | ❌ |
+
+## 🚀 Empfohlene Template-Struktur:
+
+### 1. Kompatible Versionen erstellen
+- `welcome-email-compatible.html` - E-Mail-Client-optimiert
+- `welcome-email.html` - Moderne Browser-Version
+
+### 2. Fallback-Strategien
+- **HTML-Version** für moderne Clients
+- **Text-Version** für einfache Clients
+- **Kompatible HTML** für E-Mail-Clients
+
+### 3. Testing
+- **Litmus** oder **Email on Acid** für E-Mail-Testing
+- **Verschiedene Clients** testen
+- **Mobile Geräte** berücksichtigen
+
+## 📝 Best Practices:
+
+### 1. Einfache Struktur
+- **Minimale CSS** verwenden
+- **Inline-Styles** bevorzugen
+- **Tabellen-Layout** für komplexe Strukturen
+
+### 2. Farben
+- **Hex-Codes** verwenden (`#00d4ff`)
+- **Keine Transparenz** (`rgba()` vermeiden)
+- **Hoher Kontrast** für Lesbarkeit
+
+### 3. Typografie
+- **Web-Safe Fonts** verwenden
+- **Fallback-Fonts** definieren
+- **Angemessene Schriftgrößen** (mind. 14px)
+
+### 4. Bilder
+- **Alt-Text** immer angeben
+- **Optimierte Größen** verwenden
+- **Fallback-Farben** definieren
+
+## 🎯 Sofortige Lösung:
+
+Verwende die **kompatiblen Versionen** der Templates:
+- `welcome-email-compatible.html`
+- `reset-password-compatible.html`
+
+Diese verwenden nur E-Mail-Client-kompatible CSS-Features und sollten in allen Clients korrekt angezeigt werden.
+
+---
+
+**Tipp:** Teste immer in verschiedenen E-Mail-Clients, bevor du die Templates produktiv einsetzt! 📧✨
diff --git a/public/email-templates/README.md b/public/email-templates/README.md
new file mode 100644
index 0000000..ff08511
--- /dev/null
+++ b/public/email-templates/README.md
@@ -0,0 +1,157 @@
+# NinjaCross E-Mail Templates
+
+Diese E-Mail-Templates sind im gleichen Design wie die NinjaCross-Website erstellt und können in Supabase für die E-Mail-Authentifizierung verwendet werden.
+
+## 📁 Dateien
+
+### Welcome Email (Registrierung)
+- `welcome-email.html` - Vollständige HTML-Version mit modernem Design
+- `welcome-email-compatible.html` - **EMPFOHLEN** - E-Mail-Client-optimierte Version
+- `welcome-email-simple.html` - Vereinfachte HTML-Version für bessere E-Mail-Client-Kompatibilität
+- `welcome-email.txt` - Text-Version für E-Mail-Client-Kompatibilität
+
+### Invite User (Einladung)
+- `invite-user.html` - HTML-Version für Benutzereinladungen
+- `invite-user.txt` - Text-Version für Benutzereinladungen
+
+### Magic Link (Passwortlose Anmeldung)
+- `magic-link.html` - HTML-Version für Magic Link Anmeldung
+- `magic-link.txt` - Text-Version für Magic Link Anmeldung
+
+### Change Email Address (E-Mail-Adresse ändern)
+- `change-email.html` - HTML-Version für E-Mail-Adressen-Änderung
+- `change-email.txt` - Text-Version für E-Mail-Adressen-Änderung
+
+### Reset Password (Passwort zurücksetzen)
+- `reset-password.html` - HTML-Version für Passwort-Reset
+- `reset-password-compatible.html` - E-Mail-Client-optimierte Version
+- `reset-password-optimized.html` - **EMPFOHLEN** - Verbesserte Kompatibilität
+- `reset-password-table.html` - **MAXIMALE KOMPATIBILITÄT** - Tabellen-basiert
+- `reset-password.txt` - Text-Version für Passwort-Reset
+
+### Reauthentication (Erneute Authentifizierung)
+- `reauthentication.html` - HTML-Version für erneute Authentifizierung
+- `reauthentication.txt` - Text-Version für erneute Authentifizierung
+
+## 🚀 Supabase Setup
+
+### 1. Supabase Dashboard öffnen
+1. Gehe zu deinem Supabase-Projekt
+2. Navigiere zu **Authentication** → **Email Templates**
+
+### 2. E-Mail-Templates anpassen
+1. Wähle das entsprechende Template aus der Liste:
+   - **Confirm signup** → `welcome-email-compatible.html` / `welcome-email.txt` ⭐
+   - **Invite user** → `invite-user.html` / `invite-user.txt`
+   - **Magic Link** → `magic-link.html` / `magic-link.txt`
+   - **Change Email Address** → `change-email.html` / `change-email.txt`
+   - **Reset Password** → `reset-password-table.html` / `reset-password.txt` ⭐
+   - **Reauthentication** → `reauthentication.html` / `reauthentication.txt`
+2. Ersetze den Standard-HTML-Code mit dem Inhalt aus der entsprechenden `.html` Datei
+3. Ersetze den Standard-Text mit dem Inhalt aus der entsprechenden `.txt` Datei
+
+⭐ **Empfohlene kompatible Versionen** für bessere E-Mail-Client-Unterstützung
+
+### 3. Template-Variablen
+Die folgenden Variablen werden automatisch von Supabase ersetzt:
+- `{{ .ConfirmationURL }}` - Link zur E-Mail-Bestätigung/Aktion
+- `{{ .SiteURL }}` - URL deiner Website
+- `{{ .Email }}` - E-Mail-Adresse des Benutzers
+- `{{ .NewEmail }}` - Neue E-Mail-Adresse (nur bei Change Email)
+- `{{ .InvitedBy }}` - Name des einladenden Benutzers (nur bei Invite User)
+
+### 4. E-Mail-Provider konfigurieren
+Stelle sicher, dass dein E-Mail-Provider in Supabase konfiguriert ist:
+- **SMTP Settings** in **Authentication** → **Settings**
+- Oder verwende **Supabase Edge Functions** für erweiterte E-Mail-Funktionen
+
+## 🎨 Design-Features
+
+### Farbpalette
+- **Hintergrund:** #0a0a0f (Dunkelblau)
+- **Container:** #1e293b (Dunkelgrau)
+- **Akzent:** #00d4ff (Neon-Blau)
+- **Text:** #e2e8f0 (Hellgrau)
+
+### Typografie
+- **Font:** Inter (Google Fonts)
+- **Fallback:** Arial, sans-serif
+- **Gewichtungen:** 300, 400, 500, 600, 700
+
+### Responsive Design
+- **Mobile-optimiert** für alle Bildschirmgrößen
+- **Flexible Container** mit max-width
+- **Angepasste Schriftgrößen** für mobile Geräte
+
+## 🔧 Anpassungen
+
+### Farben ändern
+Suche und ersetze die Hex-Codes in den CSS-Styles:
+```css
+/* Neon-Blau ändern */
+#00d4ff → #deine-farbe
+#0891b2 → #deine-farbe-dunkler
+```
+
+### Logo anpassen
+Ändere den Logo-Text in der HTML-Datei:
+```html
+<div class="logo">🥷 DEIN-LOGO</div>
+```
+
+### Features hinzufügen/entfernen
+Bearbeite den `.features-section` Bereich in der HTML-Datei.
+
+## 📱 E-Mail-Client-Kompatibilität
+
+### Unterstützte Clients
+- ✅ Gmail (Web & App)
+- ✅ Outlook (Web & App)
+- ✅ Apple Mail
+- ✅ Thunderbird
+- ✅ Yahoo Mail
+
+### Fallback-Strategien
+1. **HTML-Version** für moderne Clients
+2. **Text-Version** für einfache Clients
+3. **Inline-CSS** für bessere Kompatibilität
+
+## 🧪 Testing
+
+### E-Mail-Test
+1. Erstelle einen Test-Account
+2. Registriere dich mit einer Test-E-Mail
+3. Überprüfe das E-Mail-Design in verschiedenen Clients
+
+### Browser-Test
+1. Öffne `welcome-email.html` in einem Browser
+2. Teste die responsive Darstellung
+3. Überprüfe alle Links und Buttons
+
+## 🚨 E-Mail-Client-Kompatibilität
+
+**WICHTIG:** Die ursprünglichen Templates verwenden moderne CSS-Features, die in E-Mail-Clients nicht unterstützt werden.
+
+### Empfohlene Versionen:
+- **Welcome Email:** `welcome-email-compatible.html` ⭐
+- **Reset Password:** `reset-password-table.html` ⭐ (für maximale Kompatibilität)
+
+### Was wurde optimiert:
+- ❌ **Gradients** → ✅ **Einfache Hintergrundfarben**
+- ❌ **Backdrop-Filter** → ✅ **Standard-Container**
+- ❌ **Custom Fonts** → ✅ **Arial, sans-serif**
+- ❌ **Transparente Farben** → ✅ **Hex-Codes**
+
+Siehe `EMAIL-COMPATIBILITY-GUIDE.md` und `URL-CONFIGURATION-GUIDE.md` für Details.
+
+## 📞 Support
+
+Bei Fragen oder Problemen:
+- Überprüfe die Supabase-Dokumentation
+- Teste mit verschiedenen E-Mail-Providern
+- Verwende E-Mail-Testing-Tools wie Litmus oder Email on Acid
+- Verwende die **kompatiblen Versionen** für bessere E-Mail-Client-Unterstützung
+
+---
+
+**Erstellt für NinjaCross Timer Leaderboard** 🥷
diff --git a/public/email-templates/TEMPLATES-OVERVIEW.md b/public/email-templates/TEMPLATES-OVERVIEW.md
new file mode 100644
index 0000000..adc1d1a
--- /dev/null
+++ b/public/email-templates/TEMPLATES-OVERVIEW.md
@@ -0,0 +1,119 @@
+# NinjaCross E-Mail Templates - Übersicht
+
+## 📋 Alle verfügbaren Templates
+
+| Template | HTML-Datei | Text-Datei | Beschreibung |
+|----------|------------|------------|--------------|
+| **Confirm signup** | `welcome-email.html` | `welcome-email.txt` | Willkommens-E-Mail für neue Registrierungen |
+| **Invite user** | `invite-user.html` | `invite-user.txt` | Einladungs-E-Mail für neue Benutzer |
+| **Magic Link** | `magic-link.html` | `magic-link.txt` | Passwortlose Anmeldung per Magic Link |
+| **Change Email Address** | `change-email.html` | `change-email.txt` | E-Mail-Adressen-Änderung bestätigen |
+| **Reset Password** | `reset-password.html` | `reset-password.txt` | Passwort zurücksetzen |
+| **Reauthentication** | `reauthentication.html` | `reauthentication.txt` | Erneute Authentifizierung für sensible Aktionen |
+
+## 🎨 Design-Features
+
+### Einheitliche Gestaltung
+- **Dunkles Design** mit Neon-Blau-Akzenten (#00d4ff)
+- **Gradient-Titel** mit den NinjaCross-Farben
+- **Glas-Effekt Container** mit Backdrop-Filter
+- **Responsive Design** für alle Geräte
+- **Inter-Font** für moderne Typografie
+
+### Sicherheits-Features
+- **Zeitlimits** für alle Links (15 Min - 24 Std)
+- **Sicherheitshinweise** in jeder E-Mail
+- **Klare Call-to-Action Buttons**
+- **Warnungen** bei verdächtigen Aktivitäten
+
+## 🔧 Template-Variablen
+
+### Standard-Variablen (alle Templates)
+- `{{ .ConfirmationURL }}` - Link zur Bestätigung/Aktion
+- `{{ .SiteURL }}` - URL der Website
+- `{{ .Email }}` - E-Mail-Adresse des Benutzers
+
+### Spezielle Variablen
+- `{{ .NewEmail }}` - Neue E-Mail-Adresse (nur Change Email)
+- `{{ .InvitedBy }}` - Name des einladenden Benutzers (nur Invite User)
+
+## 📱 E-Mail-Client-Kompatibilität
+
+### Unterstützte Clients
+- ✅ Gmail (Web & App)
+- ✅ Outlook (Web & App)
+- ✅ Apple Mail
+- ✅ Thunderbird
+- ✅ Yahoo Mail
+- ✅ Mobile E-Mail-Apps
+
+### Fallback-Strategien
+1. **HTML-Version** für moderne Clients
+2. **Text-Version** für einfache Clients
+3. **Inline-CSS** für bessere Kompatibilität
+4. **Responsive Design** für mobile Geräte
+
+## 🚀 Supabase Integration
+
+### Setup-Schritte
+1. **Supabase Dashboard** → Authentication → Email Templates
+2. **Template auswählen** (z.B. "Confirm signup")
+3. **HTML-Code ersetzen** mit Inhalt aus `.html` Datei
+4. **Text-Code ersetzen** mit Inhalt aus `.txt` Datei
+5. **Speichern** und testen
+
+### E-Mail-Provider
+- **SMTP Settings** in Authentication → Settings
+- **Supabase Edge Functions** für erweiterte Funktionen
+- **Custom SMTP** für eigene E-Mail-Server
+
+## 🧪 Testing
+
+### E-Mail-Test
+1. **Test-Account** erstellen
+2. **Template auslösen** (Registrierung, Reset, etc.)
+3. **E-Mail prüfen** in verschiedenen Clients
+4. **Links testen** auf Funktionalität
+
+### Browser-Test
+1. **HTML-Datei** in Browser öffnen
+2. **Responsive Design** testen
+3. **Links und Buttons** überprüfen
+4. **Design-Konsistenz** sicherstellen
+
+## 📊 Template-Statistiken
+
+### Dateigrößen
+- **HTML-Templates**: ~8-12 KB
+- **Text-Templates**: ~1-2 KB
+- **Gesamt**: ~60 KB für alle Templates
+
+### Performance
+- **Ladezeit**: < 1 Sekunde
+- **Rendering**: Optimiert für alle Clients
+- **Mobile**: Vollständig responsive
+
+## 🔒 Sicherheit
+
+### Link-Sicherheit
+- **Zeitlimits**: 15 Min (Reauth) bis 24 Std (Reset)
+- **Einmalige Nutzung**: Links werden nach Verwendung ungültig
+- **HTTPS**: Alle Links verwenden sichere Verbindungen
+
+### Datenschutz
+- **Keine sensiblen Daten** in E-Mail-Inhalten
+- **Minimale Informationen** in Templates
+- **DSGVO-konform** gestaltet
+
+## 🎯 Nächste Schritte
+
+1. **Supabase konfigurieren** mit neuen Templates
+2. **E-Mail-Provider** einrichten
+3. **Test-E-Mails** versenden
+4. **Design anpassen** falls gewünscht
+5. **Monitoring** einrichten für E-Mail-Delivery
+
+---
+
+**Erstellt für NinjaCross Timer Leaderboard** 🥷
+**Alle Templates sind bereit für den produktiven Einsatz!** ✨
diff --git a/public/email-templates/URL-CONFIGURATION-GUIDE.md b/public/email-templates/URL-CONFIGURATION-GUIDE.md
new file mode 100644
index 0000000..2c113a9
--- /dev/null
+++ b/public/email-templates/URL-CONFIGURATION-GUIDE.md
@@ -0,0 +1,174 @@
+# URL-Konfiguration für NinjaCross E-Mails
+
+## 🚨 Problem: Reset-Password E-Mail funktioniert nicht
+
+**Deine Server-URL:** `ninja.reptilfpv.de:3000`
+
+## 🔧 Mögliche Ursachen:
+
+### 1. Supabase URL-Konfiguration
+Supabase muss wissen, wohin die Bestätigungslinks führen sollen.
+
+**Lösung:**
+1. **Supabase Dashboard** → **Authentication** → **URL Configuration**
+2. **Site URL** setzen auf: `https://ninja.reptilfpv.de:3000`
+3. **Redirect URLs** hinzufügen:
+   - `https://ninja.reptilfpv.de:3000/**`
+   - `http://ninja.reptilfpv.de:3000/**` (falls HTTP verwendet wird)
+
+### 2. HTTPS vs HTTP Problem
+E-Mail-Clients blockieren oft HTTP-Links in E-Mails.
+
+**Lösung:**
+- **HTTPS verwenden** für alle Links
+- **SSL-Zertifikat** für `ninja.reptilfpv.de:3000` einrichten
+- **Port 3000** in der URL kann problematisch sein
+
+### 3. E-Mail-Client-Sicherheit
+Manche E-Mail-Clients blockieren Links mit Ports oder verdächtigen Domains.
+
+**Lösung:**
+- **Standard-Ports** verwenden (80 für HTTP, 443 für HTTPS)
+- **Subdomain** verwenden: `ninja.reptilfpv.de` ohne Port
+- **Reverse Proxy** einrichten (Nginx/Apache)
+
+## 🚀 Empfohlene Lösungen:
+
+### Option 1: HTTPS mit Standard-Port
+```
+https://ninja.reptilfpv.de
+```
+- **Port 443** (Standard HTTPS)
+- **SSL-Zertifikat** erforderlich
+- **Reverse Proxy** (Nginx) einrichten
+
+### Option 2: Subdomain ohne Port
+```
+https://ninja.reptilfpv.de
+```
+- **Port 3000** intern weiterleiten
+- **Nginx** als Reverse Proxy
+- **SSL-Zertifikat** für Subdomain
+
+### Option 3: Hauptdomain verwenden
+```
+https://reptilfpv.de/ninja
+```
+- **Hauptdomain** mit Pfad
+- **Bessere E-Mail-Client-Kompatibilität**
+- **Standard-Ports** verwenden
+
+## 🔧 Nginx Reverse Proxy Setup:
+
+### 1. Nginx-Konfiguration
+```nginx
+server {
+    listen 80;
+    listen 443 ssl;
+    server_name ninja.reptilfpv.de;
+    
+    ssl_certificate /path/to/certificate.crt;
+    ssl_certificate_key /path/to/private.key;
+    
+    location / {
+        proxy_pass http://localhost:3000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_cache_bypass $http_upgrade;
+    }
+}
+```
+
+### 2. SSL-Zertifikat
+```bash
+# Let's Encrypt SSL-Zertifikat
+sudo certbot --nginx -d ninja.reptilfpv.de
+```
+
+## 📧 E-Mail-Template-Optimierungen:
+
+### 1. Absolute URLs verwenden
+```html
+<!-- ❌ Relativ -->
+<a href="/reset-password">Reset</a>
+
+<!-- ✅ Absolut -->
+<a href="https://ninja.reptilfpv.de/reset-password">Reset</a>
+```
+
+### 2. HTTPS erzwingen
+```html
+<!-- ✅ Immer HTTPS verwenden -->
+<a href="https://ninja.reptilfpv.de{{ .ConfirmationURL }}">Reset</a>
+```
+
+### 3. Fallback-URLs
+```html
+<!-- ✅ Mit Fallback -->
+<a href="{{ .ConfirmationURL }}">Reset</a>
+<p>Falls der Link nicht funktioniert: https://ninja.reptilfpv.de</p>
+```
+
+## 🧪 Testing:
+
+### 1. E-Mail-Links testen
+```bash
+# Test-URLs
+curl -I https://ninja.reptilfpv.de:3000
+curl -I https://ninja.reptilfpv.de
+curl -I http://ninja.reptilfpv.de:3000
+```
+
+### 2. E-Mail-Client-Test
+- **Gmail** - Links in E-Mail testen
+- **Outlook** - Sicherheitswarnungen prüfen
+- **Apple Mail** - Link-Funktionalität testen
+
+### 3. Supabase-Logs prüfen
+- **Authentication Logs** in Supabase Dashboard
+- **Fehler-Meldungen** analysieren
+- **Redirect-URLs** überprüfen
+
+## 🎯 Sofortige Lösung:
+
+### 1. Supabase konfigurieren
+```
+Site URL: https://ninja.reptilfpv.de:3000
+Redirect URLs: 
+- https://ninja.reptilfpv.de:3000/**
+- https://ninja.reptilfpv.de:3000/auth/callback
+```
+
+### 2. Optimierte Templates verwenden
+- **`reset-password-optimized.html`** - Verbesserte Kompatibilität
+- **`reset-password-table.html`** - Tabellen-basiert für maximale Kompatibilität
+
+### 3. HTTPS einrichten
+- **SSL-Zertifikat** für `ninja.reptilfpv.de:3000`
+- **Oder** Reverse Proxy mit Standard-Port
+
+## 📞 Debugging:
+
+### 1. E-Mail-Links prüfen
+- **Link in E-Mail** kopieren und in Browser testen
+- **URL-Struktur** analysieren
+- **Redirects** verfolgen
+
+### 2. Supabase-Logs
+- **Authentication** → **Logs** in Supabase Dashboard
+- **Fehler-Meldungen** suchen
+- **URL-Parameter** prüfen
+
+### 3. Browser-Entwicklertools
+- **Network-Tab** für Redirects
+- **Console** für JavaScript-Fehler
+- **Security-Tab** für HTTPS-Probleme
+
+---
+
+**Empfehlung:** Verwende `reset-password-table.html` mit HTTPS und Standard-Port für beste Kompatibilität! 🚀
diff --git a/public/email-templates/change-email.html b/public/email-templates/change-email.html
new file mode 100644
index 0000000..50397de
--- /dev/null
+++ b/public/email-templates/change-email.html
@@ -0,0 +1,274 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>E-Mail-Adresse ändern - NinjaCross</title>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Inter', sans-serif;
+            background: #0a0a0f;
+            color: #ffffff;
+            line-height: 1.6;
+            margin: 0;
+            padding: 0;
+        }
+        
+        .email-container {
+            max-width: 600px;
+            margin: 0 auto;
+            background: #0a0a0f;
+            background-image: 
+                radial-gradient(circle at 20% 80%, #1a1a2e 0%, transparent 50%),
+                radial-gradient(circle at 80% 20%, #16213e 0%, transparent 50%),
+                radial-gradient(circle at 40% 40%, #0f3460 0%, transparent 50%);
+        }
+        
+        .email-header {
+            text-align: center;
+            padding: 3rem 2rem 2rem;
+        }
+        
+        .logo {
+            font-size: 2.5rem;
+            font-weight: 700;
+            background: linear-gradient(135deg, #00d4ff, #ff6b35, #ffd700);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            margin-bottom: 0.5rem;
+            letter-spacing: -0.02em;
+        }
+        
+        .tagline {
+            color: #94a3b8;
+            font-size: 1rem;
+            font-weight: 400;
+        }
+        
+        .email-content {
+            background: rgba(30, 41, 59, 0.95);
+            backdrop-filter: blur(20px);
+            border: 1px solid rgba(51, 65, 85, 0.3);
+            margin: 0 2rem;
+            padding: 2.5rem;
+            border-radius: 1.5rem;
+            box-shadow: 
+                0 25px 50px rgba(0, 0, 0, 0.3),
+                0 0 0 1px rgba(0, 212, 255, 0.1);
+        }
+        
+        .change-title {
+            font-size: 1.75rem;
+            font-weight: 600;
+            color: #e2e8f0;
+            text-align: center;
+            margin-bottom: 1.5rem;
+        }
+        
+        .change-message {
+            color: #cbd5e1;
+            font-size: 1rem;
+            margin-bottom: 2rem;
+            text-align: center;
+        }
+        
+        .email-info {
+            background: rgba(51, 65, 85, 0.3);
+            border: 1px solid rgba(0, 212, 255, 0.1);
+            border-radius: 0.75rem;
+            padding: 1.5rem;
+            margin-bottom: 2rem;
+        }
+        
+        .email-row {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 0.75rem 0;
+            border-bottom: 1px solid rgba(51, 65, 85, 0.5);
+        }
+        
+        .email-row:last-child {
+            border-bottom: none;
+        }
+        
+        .email-label {
+            color: #94a3b8;
+            font-size: 0.9rem;
+            font-weight: 500;
+        }
+        
+        .email-value {
+            color: #e2e8f0;
+            font-size: 0.9rem;
+            font-weight: 600;
+        }
+        
+        .cta-button {
+            display: inline-block;
+            width: 100%;
+            padding: 1rem 2rem;
+            background: linear-gradient(135deg, #00d4ff, #0891b2);
+            color: white;
+            text-decoration: none;
+            border-radius: 0.75rem;
+            font-weight: 600;
+            font-size: 1rem;
+            text-align: center;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            box-shadow: 0 4px 12px rgba(0, 212, 255, 0.3);
+            transition: all 0.2s ease;
+            margin-bottom: 2rem;
+        }
+        
+        .cta-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 16px rgba(0, 212, 255, 0.4);
+        }
+        
+        .warning-info {
+            background: rgba(245, 158, 11, 0.1);
+            border: 1px solid rgba(245, 158, 11, 0.3);
+            border-radius: 0.75rem;
+            padding: 1rem;
+            margin-top: 2rem;
+        }
+        
+        .warning-title {
+            color: #f59e0b;
+            font-weight: 600;
+            font-size: 0.9rem;
+            margin-bottom: 0.5rem;
+            text-align: center;
+        }
+        
+        .warning-text {
+            color: #fbbf24;
+            font-size: 0.85rem;
+            text-align: center;
+        }
+        
+        .email-footer {
+            text-align: center;
+            padding: 2rem;
+            color: #64748b;
+            font-size: 0.875rem;
+        }
+        
+        .footer-links {
+            margin-top: 1rem;
+        }
+        
+        .footer-links a {
+            color: #00d4ff;
+            text-decoration: none;
+            margin: 0 1rem;
+        }
+        
+        .footer-links a:hover {
+            color: #0891b2;
+        }
+        
+        .divider {
+            height: 1px;
+            background: linear-gradient(90deg, transparent, #334155, transparent);
+            margin: 2rem 0;
+        }
+        
+        /* Mobile Responsive */
+        @media (max-width: 600px) {
+            .email-content {
+                margin: 0 1rem;
+                padding: 2rem;
+            }
+            
+            .email-header {
+                padding: 2rem 1rem 1rem;
+            }
+            
+            .logo {
+                font-size: 2rem;
+            }
+            
+            .change-title {
+                font-size: 1.5rem;
+            }
+            
+            .email-row {
+                flex-direction: column;
+                align-items: flex-start;
+                gap: 0.25rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="email-container">
+        <!-- Header -->
+        <div class="email-header">
+            <div class="logo">🥷 NINJACROSS</div>
+            <div class="tagline">Die ultimative Timer-Rangliste</div>
+        </div>
+        
+        <!-- Main Content -->
+        <div class="email-content">
+            <h1 class="change-title">E-Mail-Adresse ändern 📧</h1>
+            
+            <p class="change-message">
+                Du möchtest deine E-Mail-Adresse ändern. Bestätige die neue E-Mail-Adresse, 
+                um die Änderung abzuschließen.
+            </p>
+            
+            <div class="email-info">
+                <div class="email-row">
+                    <span class="email-label">Aktuelle E-Mail:</span>
+                    <span class="email-value">{{ .Email }}</span>
+                </div>
+                <div class="email-row">
+                    <span class="email-label">Neue E-Mail:</span>
+                    <span class="email-value">{{ .NewEmail }}</span>
+                </div>
+            </div>
+            
+            <a href="{{ .ConfirmationURL }}" class="cta-button">
+                ✅ E-Mail-Adresse bestätigen
+            </a>
+            
+            <div class="warning-info">
+                <div class="warning-title">⚠️ Wichtiger Hinweis</div>
+                <div class="warning-text">
+                    Nach der Bestätigung wird deine neue E-Mail-Adresse für alle zukünftigen 
+                    Benachrichtigungen und Anmeldungen verwendet.
+                </div>
+            </div>
+        </div>
+        
+        <!-- Footer -->
+        <div class="email-footer">
+            <p>
+                Falls du diese Änderung nicht angefordert hast, kannst du diese E-Mail ignorieren.
+            </p>
+            
+            <div class="footer-links">
+                <a href="{{ .SiteURL }}">Zur Website</a>
+                <a href="{{ .SiteURL }}/support">Support</a>
+                <a href="{{ .SiteURL }}/privacy">Datenschutz</a>
+            </div>
+            
+            <p style="margin-top: 1.5rem; font-size: 0.75rem; color: #64748b;">
+                © 2024 NinjaCross. Alle Rechte vorbehalten.
+            </p>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/public/email-templates/change-email.txt b/public/email-templates/change-email.txt
new file mode 100644
index 0000000..4041a81
--- /dev/null
+++ b/public/email-templates/change-email.txt
@@ -0,0 +1,29 @@
+🥷 NINJACROSS - Die ultimative Timer-Rangliste
+================================================
+
+E-Mail-Adresse ändern 📧
+
+Du möchtest deine E-Mail-Adresse ändern. Bestätige die neue E-Mail-Adresse, 
+um die Änderung abzuschließen.
+
+📧 E-Mail-Informationen:
+- Aktuelle E-Mail: {{ .Email }}
+- Neue E-Mail: {{ .NewEmail }}
+
+✅ E-Mail-Adresse bestätigen:
+{{ .ConfirmationURL }}
+
+⚠️ Wichtiger Hinweis:
+Nach der Bestätigung wird deine neue E-Mail-Adresse für alle zukünftigen 
+Benachrichtigungen und Anmeldungen verwendet.
+
+================================================
+
+Falls du diese Änderung nicht angefordert hast, kannst du diese E-Mail ignorieren.
+
+Links:
+- Zur Website: {{ .SiteURL }}
+- Support: {{ .SiteURL }}/support
+- Datenschutz: {{ .SiteURL }}/privacy
+
+© 2024 NinjaCross. Alle Rechte vorbehalten.
diff --git a/public/email-templates/invite-user.html b/public/email-templates/invite-user.html
new file mode 100644
index 0000000..d48619b
--- /dev/null
+++ b/public/email-templates/invite-user.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Einladung zu NinjaCross</title>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Inter', sans-serif;
+            background: #0a0a0f;
+            color: #ffffff;
+            line-height: 1.6;
+            margin: 0;
+            padding: 0;
+        }
+        
+        .email-container {
+            max-width: 600px;
+            margin: 0 auto;
+            background: #0a0a0f;
+            background-image: 
+                radial-gradient(circle at 20% 80%, #1a1a2e 0%, transparent 50%),
+                radial-gradient(circle at 80% 20%, #16213e 0%, transparent 50%),
+                radial-gradient(circle at 40% 40%, #0f3460 0%, transparent 50%);
+        }
+        
+        .email-header {
+            text-align: center;
+            padding: 3rem 2rem 2rem;
+        }
+        
+        .logo {
+            font-size: 2.5rem;
+            font-weight: 700;
+            background: linear-gradient(135deg, #00d4ff, #ff6b35, #ffd700);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            margin-bottom: 0.5rem;
+            letter-spacing: -0.02em;
+        }
+        
+        .tagline {
+            color: #94a3b8;
+            font-size: 1rem;
+            font-weight: 400;
+        }
+        
+        .email-content {
+            background: rgba(30, 41, 59, 0.95);
+            backdrop-filter: blur(20px);
+            border: 1px solid rgba(51, 65, 85, 0.3);
+            margin: 0 2rem;
+            padding: 2.5rem;
+            border-radius: 1.5rem;
+            box-shadow: 
+                0 25px 50px rgba(0, 0, 0, 0.3),
+                0 0 0 1px rgba(0, 212, 255, 0.1);
+        }
+        
+        .invite-title {
+            font-size: 1.75rem;
+            font-weight: 600;
+            color: #e2e8f0;
+            text-align: center;
+            margin-bottom: 1.5rem;
+        }
+        
+        .invite-message {
+            color: #cbd5e1;
+            font-size: 1rem;
+            margin-bottom: 2rem;
+            text-align: center;
+        }
+        
+        .inviter-info {
+            background: rgba(51, 65, 85, 0.3);
+            border: 1px solid rgba(0, 212, 255, 0.1);
+            border-radius: 0.75rem;
+            padding: 1.5rem;
+            margin-bottom: 2rem;
+            text-align: center;
+        }
+        
+        .inviter-name {
+            font-size: 1.25rem;
+            font-weight: 600;
+            color: #00d4ff;
+            margin-bottom: 0.5rem;
+        }
+        
+        .inviter-role {
+            color: #94a3b8;
+            font-size: 0.9rem;
+        }
+        
+        .cta-button {
+            display: inline-block;
+            width: 100%;
+            padding: 1rem 2rem;
+            background: linear-gradient(135deg, #00d4ff, #0891b2);
+            color: white;
+            text-decoration: none;
+            border-radius: 0.75rem;
+            font-weight: 600;
+            font-size: 1rem;
+            text-align: center;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            box-shadow: 0 4px 12px rgba(0, 212, 255, 0.3);
+            transition: all 0.2s ease;
+            margin-bottom: 2rem;
+        }
+        
+        .cta-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 16px rgba(0, 212, 255, 0.4);
+        }
+        
+        .features-section {
+            margin-top: 2rem;
+        }
+        
+        .features-title {
+            font-size: 1.25rem;
+            font-weight: 600;
+            color: #e2e8f0;
+            margin-bottom: 1rem;
+            text-align: center;
+        }
+        
+        .feature-item {
+            display: flex;
+            align-items: center;
+            margin-bottom: 1rem;
+            padding: 1rem;
+            background: rgba(51, 65, 85, 0.3);
+            border-radius: 0.75rem;
+            border: 1px solid rgba(0, 212, 255, 0.1);
+        }
+        
+        .feature-icon {
+            font-size: 1.5rem;
+            margin-right: 1rem;
+            width: 2rem;
+            text-align: center;
+        }
+        
+        .feature-text {
+            color: #cbd5e1;
+            font-size: 0.95rem;
+        }
+        
+        .email-footer {
+            text-align: center;
+            padding: 2rem;
+            color: #64748b;
+            font-size: 0.875rem;
+        }
+        
+        .footer-links {
+            margin-top: 1rem;
+        }
+        
+        .footer-links a {
+            color: #00d4ff;
+            text-decoration: none;
+            margin: 0 1rem;
+        }
+        
+        .footer-links a:hover {
+            color: #0891b2;
+        }
+        
+        .divider {
+            height: 1px;
+            background: linear-gradient(90deg, transparent, #334155, transparent);
+            margin: 2rem 0;
+        }
+        
+        /* Mobile Responsive */
+        @media (max-width: 600px) {
+            .email-content {
+                margin: 0 1rem;
+                padding: 2rem;
+            }
+            
+            .email-header {
+                padding: 2rem 1rem 1rem;
+            }
+            
+            .logo {
+                font-size: 2rem;
+            }
+            
+            .invite-title {
+                font-size: 1.5rem;
+            }
+            
+            .feature-item {
+                flex-direction: column;
+                text-align: center;
+            }
+            
+            .feature-icon {
+                margin-right: 0;
+                margin-bottom: 0.5rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="email-container">
+        <!-- Header -->
+        <div class="email-header">
+            <div class="logo">🥷 NINJACROSS</div>
+            <div class="tagline">Die ultimative Timer-Rangliste</div>
+        </div>
+        
+        <!-- Main Content -->
+        <div class="email-content">
+            <h1 class="invite-title">Du wurdest eingeladen! 🎉</h1>
+            
+            <p class="invite-message">
+                Du wurdest von einem Administrator zu NinjaCross eingeladen. 
+                Klicke auf den Button unten, um dein Konto zu erstellen und der Community beizutreten.
+            </p>
+            
+            <div class="inviter-info">
+                <div class="inviter-name">{{ .InvitedBy }}</div>
+                <div class="inviter-role">hat dich zu NinjaCross eingeladen</div>
+            </div>
+            
+            <a href="{{ .ConfirmationURL }}" class="cta-button">
+                🚀 Konto erstellen
+            </a>
+            
+            <div class="divider"></div>
+            
+            <!-- Features Section -->
+            <div class="features-section">
+                <h2 class="features-title">Was dich erwartet:</h2>
+                
+                <div class="feature-item">
+                    <div class="feature-icon">🏃‍♂️</div>
+                    <div class="feature-text">
+                        <strong>Timer-Tracking:</strong> Erfasse deine Zeiten und verfolge deinen Fortschritt
+                    </div>
+                </div>
+                
+                <div class="feature-item">
+                    <div class="feature-icon">🏆</div>
+                    <div class="feature-text">
+                        <strong>Leaderboards:</strong> Vergleiche dich mit anderen Spielern und erreiche die Spitze
+                    </div>
+                </div>
+                
+                <div class="feature-item">
+                    <div class="feature-icon">📊</div>
+                    <div class="feature-text">
+                        <strong>Statistiken:</strong> Detaillierte Analysen deiner Performance und Verbesserungen
+                    </div>
+                </div>
+                
+                <div class="feature-item">
+                    <div class="feature-icon">🌍</div>
+                    <div class="feature-text">
+                        <strong>Multi-Location:</strong> Spiele an verschiedenen Standorten und sammle Erfahrungen
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <!-- Footer -->
+        <div class="email-footer">
+            <p>
+                Falls du diese Einladung nicht erwartet hast, kannst du diese E-Mail ignorieren.
+            </p>
+            
+            <div class="footer-links">
+                <a href="{{ .SiteURL }}">Zur Website</a>
+                <a href="{{ .SiteURL }}/support">Support</a>
+                <a href="{{ .SiteURL }}/privacy">Datenschutz</a>
+            </div>
+            
+            <p style="margin-top: 1.5rem; font-size: 0.75rem; color: #64748b;">
+                © 2024 NinjaCross. Alle Rechte vorbehalten.
+            </p>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/public/email-templates/invite-user.txt b/public/email-templates/invite-user.txt
new file mode 100644
index 0000000..fc80052
--- /dev/null
+++ b/public/email-templates/invite-user.txt
@@ -0,0 +1,34 @@
+🥷 NINJACROSS - Die ultimative Timer-Rangliste
+================================================
+
+Du wurdest eingeladen! 🎉
+
+Du wurdest von einem Administrator zu NinjaCross eingeladen. 
+Klicke auf den Link unten, um dein Konto zu erstellen und der Community beizutreten.
+
+👤 Einladung von: {{ .InvitedBy }}
+
+🚀 Konto erstellen:
+{{ .ConfirmationURL }}
+
+Was dich erwartet:
+==================
+
+🏃‍♂️ Timer-Tracking: Erfasse deine Zeiten und verfolge deinen Fortschritt
+
+🏆 Leaderboards: Vergleiche dich mit anderen Spielern und erreiche die Spitze
+
+📊 Statistiken: Detaillierte Analysen deiner Performance und Verbesserungen
+
+🌍 Multi-Location: Spiele an verschiedenen Standorten und sammle Erfahrungen
+
+================================================
+
+Falls du diese Einladung nicht erwartet hast, kannst du diese E-Mail ignorieren.
+
+Links:
+- Zur Website: {{ .SiteURL }}
+- Support: {{ .SiteURL }}/support
+- Datenschutz: {{ .SiteURL }}/privacy
+
+© 2024 NinjaCross. Alle Rechte vorbehalten.
diff --git a/public/email-templates/magic-link.html b/public/email-templates/magic-link.html
new file mode 100644
index 0000000..8433cd0
--- /dev/null
+++ b/public/email-templates/magic-link.html
@@ -0,0 +1,257 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Magic Link - NinjaCross</title>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Inter', sans-serif;
+            background: #0a0a0f;
+            color: #ffffff;
+            line-height: 1.6;
+            margin: 0;
+            padding: 0;
+        }
+        
+        .email-container {
+            max-width: 600px;
+            margin: 0 auto;
+            background: #0a0a0f;
+            background-image: 
+                radial-gradient(circle at 20% 80%, #1a1a2e 0%, transparent 50%),
+                radial-gradient(circle at 80% 20%, #16213e 0%, transparent 50%),
+                radial-gradient(circle at 40% 40%, #0f3460 0%, transparent 50%);
+        }
+        
+        .email-header {
+            text-align: center;
+            padding: 3rem 2rem 2rem;
+        }
+        
+        .logo {
+            font-size: 2.5rem;
+            font-weight: 700;
+            background: linear-gradient(135deg, #00d4ff, #ff6b35, #ffd700);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            margin-bottom: 0.5rem;
+            letter-spacing: -0.02em;
+        }
+        
+        .tagline {
+            color: #94a3b8;
+            font-size: 1rem;
+            font-weight: 400;
+        }
+        
+        .email-content {
+            background: rgba(30, 41, 59, 0.95);
+            backdrop-filter: blur(20px);
+            border: 1px solid rgba(51, 65, 85, 0.3);
+            margin: 0 2rem;
+            padding: 2.5rem;
+            border-radius: 1.5rem;
+            box-shadow: 
+                0 25px 50px rgba(0, 0, 0, 0.3),
+                0 0 0 1px rgba(0, 212, 255, 0.1);
+        }
+        
+        .magic-title {
+            font-size: 1.75rem;
+            font-weight: 600;
+            color: #e2e8f0;
+            text-align: center;
+            margin-bottom: 1.5rem;
+        }
+        
+        .magic-message {
+            color: #cbd5e1;
+            font-size: 1rem;
+            margin-bottom: 2rem;
+            text-align: center;
+        }
+        
+        .magic-info {
+            background: rgba(51, 65, 85, 0.3);
+            border: 1px solid rgba(0, 212, 255, 0.1);
+            border-radius: 0.75rem;
+            padding: 1.5rem;
+            margin-bottom: 2rem;
+            text-align: center;
+        }
+        
+        .magic-icon {
+            font-size: 3rem;
+            margin-bottom: 1rem;
+            display: block;
+        }
+        
+        .magic-description {
+            color: #94a3b8;
+            font-size: 0.9rem;
+            margin-bottom: 1rem;
+        }
+        
+        .cta-button {
+            display: inline-block;
+            width: 100%;
+            padding: 1rem 2rem;
+            background: linear-gradient(135deg, #00d4ff, #0891b2);
+            color: white;
+            text-decoration: none;
+            border-radius: 0.75rem;
+            font-weight: 600;
+            font-size: 1rem;
+            text-align: center;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            box-shadow: 0 4px 12px rgba(0, 212, 255, 0.3);
+            transition: all 0.2s ease;
+            margin-bottom: 2rem;
+        }
+        
+        .cta-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 16px rgba(0, 212, 255, 0.4);
+        }
+        
+        .security-info {
+            background: rgba(34, 197, 94, 0.1);
+            border: 1px solid rgba(34, 197, 94, 0.3);
+            border-radius: 0.75rem;
+            padding: 1rem;
+            margin-top: 2rem;
+        }
+        
+        .security-title {
+            color: #22c55e;
+            font-weight: 600;
+            font-size: 0.9rem;
+            margin-bottom: 0.5rem;
+            text-align: center;
+        }
+        
+        .security-text {
+            color: #86efac;
+            font-size: 0.85rem;
+            text-align: center;
+        }
+        
+        .email-footer {
+            text-align: center;
+            padding: 2rem;
+            color: #64748b;
+            font-size: 0.875rem;
+        }
+        
+        .footer-links {
+            margin-top: 1rem;
+        }
+        
+        .footer-links a {
+            color: #00d4ff;
+            text-decoration: none;
+            margin: 0 1rem;
+        }
+        
+        .footer-links a:hover {
+            color: #0891b2;
+        }
+        
+        .divider {
+            height: 1px;
+            background: linear-gradient(90deg, transparent, #334155, transparent);
+            margin: 2rem 0;
+        }
+        
+        /* Mobile Responsive */
+        @media (max-width: 600px) {
+            .email-content {
+                margin: 0 1rem;
+                padding: 2rem;
+            }
+            
+            .email-header {
+                padding: 2rem 1rem 1rem;
+            }
+            
+            .logo {
+                font-size: 2rem;
+            }
+            
+            .magic-title {
+                font-size: 1.5rem;
+            }
+            
+            .magic-icon {
+                font-size: 2.5rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="email-container">
+        <!-- Header -->
+        <div class="email-header">
+            <div class="logo">🥷 NINJACROSS</div>
+            <div class="tagline">Die ultimative Timer-Rangliste</div>
+        </div>
+        
+        <!-- Main Content -->
+        <div class="email-content">
+            <h1 class="magic-title">Dein Magic Link ist da! ✨</h1>
+            
+            <p class="magic-message">
+                Du hast einen Magic Link angefordert. Klicke auf den Button unten, 
+                um dich sicher und ohne Passwort bei NinjaCross anzumelden.
+            </p>
+            
+            <div class="magic-info">
+                <span class="magic-icon">🔗</span>
+                <div class="magic-description">
+                    Dieser Link ist sicher und führt dich direkt zu deinem Konto
+                </div>
+            </div>
+            
+            <a href="{{ .ConfirmationURL }}" class="cta-button">
+                🚀 Anmelden
+            </a>
+            
+            <div class="security-info">
+                <div class="security-title">🔒 Sicherheitshinweis</div>
+                <div class="security-text">
+                    Dieser Link ist nur für dich bestimmt und verfällt nach 24 Stunden. 
+                    Teile ihn nicht mit anderen Personen.
+                </div>
+            </div>
+        </div>
+        
+        <!-- Footer -->
+        <div class="email-footer">
+            <p>
+                Falls du diesen Magic Link nicht angefordert hast, kannst du diese E-Mail ignorieren.
+            </p>
+            
+            <div class="footer-links">
+                <a href="{{ .SiteURL }}">Zur Website</a>
+                <a href="{{ .SiteURL }}/support">Support</a>
+                <a href="{{ .SiteURL }}/privacy">Datenschutz</a>
+            </div>
+            
+            <p style="margin-top: 1.5rem; font-size: 0.75rem; color: #64748b;">
+                © 2024 NinjaCross. Alle Rechte vorbehalten.
+            </p>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/public/email-templates/magic-link.txt b/public/email-templates/magic-link.txt
new file mode 100644
index 0000000..21ae685
--- /dev/null
+++ b/public/email-templates/magic-link.txt
@@ -0,0 +1,25 @@
+🥷 NINJACROSS - Die ultimative Timer-Rangliste
+================================================
+
+Dein Magic Link ist da! ✨
+
+Du hast einen Magic Link angefordert. Klicke auf den Link unten, 
+um dich sicher und ohne Passwort bei NinjaCross anzumelden.
+
+🔗 Magic Link:
+{{ .ConfirmationURL }}
+
+🔒 Sicherheitshinweis:
+Dieser Link ist nur für dich bestimmt und verfällt nach 24 Stunden. 
+Teile ihn nicht mit anderen Personen.
+
+================================================
+
+Falls du diesen Magic Link nicht angefordert hast, kannst du diese E-Mail ignorieren.
+
+Links:
+- Zur Website: {{ .SiteURL }}
+- Support: {{ .SiteURL }}/support
+- Datenschutz: {{ .SiteURL }}/privacy
+
+© 2024 NinjaCross. Alle Rechte vorbehalten.
diff --git a/public/email-templates/reauthentication.html b/public/email-templates/reauthentication.html
new file mode 100644
index 0000000..e80c04c
--- /dev/null
+++ b/public/email-templates/reauthentication.html
@@ -0,0 +1,327 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Erneute Authentifizierung - NinjaCross</title>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Inter', sans-serif;
+            background: #0a0a0f;
+            color: #ffffff;
+            line-height: 1.6;
+            margin: 0;
+            padding: 0;
+        }
+        
+        .email-container {
+            max-width: 600px;
+            margin: 0 auto;
+            background: #0a0a0f;
+            background-image: 
+                radial-gradient(circle at 20% 80%, #1a1a2e 0%, transparent 50%),
+                radial-gradient(circle at 80% 20%, #16213e 0%, transparent 50%),
+                radial-gradient(circle at 40% 40%, #0f3460 0%, transparent 50%);
+        }
+        
+        .email-header {
+            text-align: center;
+            padding: 3rem 2rem 2rem;
+        }
+        
+        .logo {
+            font-size: 2.5rem;
+            font-weight: 700;
+            background: linear-gradient(135deg, #00d4ff, #ff6b35, #ffd700);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            margin-bottom: 0.5rem;
+            letter-spacing: -0.02em;
+        }
+        
+        .tagline {
+            color: #94a3b8;
+            font-size: 1rem;
+            font-weight: 400;
+        }
+        
+        .email-content {
+            background: rgba(30, 41, 59, 0.95);
+            backdrop-filter: blur(20px);
+            border: 1px solid rgba(51, 65, 85, 0.3);
+            margin: 0 2rem;
+            padding: 2.5rem;
+            border-radius: 1.5rem;
+            box-shadow: 
+                0 25px 50px rgba(0, 0, 0, 0.3),
+                0 0 0 1px rgba(0, 212, 255, 0.1);
+        }
+        
+        .reauth-title {
+            font-size: 1.75rem;
+            font-weight: 600;
+            color: #e2e8f0;
+            text-align: center;
+            margin-bottom: 1.5rem;
+        }
+        
+        .reauth-message {
+            color: #cbd5e1;
+            font-size: 1rem;
+            margin-bottom: 2rem;
+            text-align: center;
+        }
+        
+        .reauth-info {
+            background: rgba(51, 65, 85, 0.3);
+            border: 1px solid rgba(0, 212, 255, 0.1);
+            border-radius: 0.75rem;
+            padding: 1.5rem;
+            margin-bottom: 2rem;
+            text-align: center;
+        }
+        
+        .reauth-icon {
+            font-size: 3rem;
+            margin-bottom: 1rem;
+            display: block;
+        }
+        
+        .reauth-description {
+            color: #94a3b8;
+            font-size: 0.9rem;
+            margin-bottom: 1rem;
+        }
+        
+        .cta-button {
+            display: inline-block;
+            width: 100%;
+            padding: 1rem 2rem;
+            background: linear-gradient(135deg, #00d4ff, #0891b2);
+            color: white;
+            text-decoration: none;
+            border-radius: 0.75rem;
+            font-weight: 600;
+            font-size: 1rem;
+            text-align: center;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            box-shadow: 0 4px 12px rgba(0, 212, 255, 0.3);
+            transition: all 0.2s ease;
+            margin-bottom: 2rem;
+        }
+        
+        .cta-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 16px rgba(0, 212, 255, 0.4);
+        }
+        
+        .security-info {
+            background: rgba(34, 197, 94, 0.1);
+            border: 1px solid rgba(34, 197, 94, 0.3);
+            border-radius: 0.75rem;
+            padding: 1.5rem;
+            margin-top: 2rem;
+        }
+        
+        .security-title {
+            color: #22c55e;
+            font-weight: 600;
+            font-size: 1rem;
+            margin-bottom: 1rem;
+            text-align: center;
+        }
+        
+        .security-text {
+            color: #86efac;
+            font-size: 0.9rem;
+            text-align: center;
+            line-height: 1.6;
+        }
+        
+        .warning-info {
+            background: rgba(245, 158, 11, 0.1);
+            border: 1px solid rgba(245, 158, 11, 0.3);
+            border-radius: 0.75rem;
+            padding: 1rem;
+            margin-top: 1.5rem;
+        }
+        
+        .warning-title {
+            color: #f59e0b;
+            font-weight: 600;
+            font-size: 0.9rem;
+            margin-bottom: 0.5rem;
+            text-align: center;
+        }
+        
+        .warning-text {
+            color: #fbbf24;
+            font-size: 0.85rem;
+            text-align: center;
+        }
+        
+        .token-section {
+            background: rgba(0, 212, 255, 0.1);
+            border: 1px solid rgba(0, 212, 255, 0.3);
+            border-radius: 0.75rem;
+            padding: 1.5rem;
+            margin: 2rem 0;
+            text-align: center;
+        }
+        
+        .token-display {
+            margin-top: 1rem;
+        }
+        
+        .token-code {
+            background: #1e293b;
+            border: 2px solid #00d4ff;
+            border-radius: 0.5rem;
+            padding: 1rem;
+            font-family: 'Courier New', monospace;
+            font-size: 1.5rem;
+            font-weight: 700;
+            color: #00d4ff;
+            letter-spacing: 0.1em;
+            text-align: center;
+            margin: 0 auto;
+            max-width: 300px;
+            box-shadow: 0 0 20px rgba(0, 212, 255, 0.2);
+        }
+        
+        .email-footer {
+            text-align: center;
+            padding: 2rem;
+            color: #64748b;
+            font-size: 0.875rem;
+        }
+        
+        .footer-links {
+            margin-top: 1rem;
+        }
+        
+        .footer-links a {
+            color: #00d4ff;
+            text-decoration: none;
+            margin: 0 1rem;
+        }
+        
+        .footer-links a:hover {
+            color: #0891b2;
+        }
+        
+        .divider {
+            height: 1px;
+            background: linear-gradient(90deg, transparent, #334155, transparent);
+            margin: 2rem 0;
+        }
+        
+        /* Mobile Responsive */
+        @media (max-width: 600px) {
+            .email-content {
+                margin: 0 1rem;
+                padding: 2rem;
+            }
+            
+            .email-header {
+                padding: 2rem 1rem 1rem;
+            }
+            
+            .logo {
+                font-size: 2rem;
+            }
+            
+            .reauth-title {
+                font-size: 1.5rem;
+            }
+            
+            .reauth-icon {
+                font-size: 2.5rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="email-container">
+        <!-- Header -->
+        <div class="email-header">
+            <div class="logo">🥷 NINJACROSS</div>
+            <div class="tagline">Die ultimative Timer-Rangliste</div>
+        </div>
+        
+        <!-- Main Content -->
+        <div class="email-content">
+            <h1 class="reauth-title">Erneute Authentifizierung erforderlich 🔒</h1>
+            
+            <p class="reauth-message">
+                Für diese Aktion ist eine erneute Authentifizierung erforderlich. 
+                Klicke auf den Button unten, um deine Identität zu bestätigen.
+            </p>
+            
+            <div class="reauth-info">
+                <span class="reauth-icon">🛡️</span>
+                <div class="reauth-description">
+                    Diese zusätzliche Sicherheitsmaßnahme schützt dein Konto
+                </div>
+            </div>
+            
+            <!-- Token Section -->
+            <div class="token-section">
+                <h2 style="color: #e2e8f0; text-align: center; margin-bottom: 1rem; font-size: 1.25rem;">Bestätigungscode</h2>
+                <div class="token-display">
+                    <p style="color: #cbd5e1; text-align: center; margin-bottom: 0.5rem;">Gib diesen Code ein:</p>
+                    <div class="token-code">{{ .Token }}</div>
+                </div>
+            </div>
+            
+            <a href="{{ .ConfirmationURL }}" class="cta-button">
+                🔐 Identität bestätigen
+            </a>
+            
+            <div class="security-info">
+                <div class="security-title">🔒 Warum ist das nötig?</div>
+                <div class="security-text">
+                    Bestimmte Aktionen wie das Ändern sensibler Daten oder das Zugreifen auf 
+                    administrative Funktionen erfordern eine erneute Authentifizierung, 
+                    um die Sicherheit deines Kontos zu gewährleisten.
+                </div>
+            </div>
+            
+            <div class="warning-info">
+                <div class="warning-title">⏰ Zeitlimit</div>
+                <div class="warning-text">
+                    Dieser Link verfällt nach 15 Minuten. Falls du diese Aktion nicht 
+                    angefordert hast, kannst du diese E-Mail ignorieren.
+                </div>
+            </div>
+        </div>
+        
+        <!-- Footer -->
+        <div class="email-footer">
+            <p>
+                Falls du diese Aktion nicht angefordert hast, kannst du diese E-Mail ignorieren.
+            </p>
+            
+            <div class="footer-links">
+                <a href="{{ .SiteURL }}">Zur Website</a>
+                <a href="{{ .SiteURL }}/support">Support</a>
+                <a href="{{ .SiteURL }}/privacy">Datenschutz</a>
+            </div>
+            
+            <p style="margin-top: 1.5rem; font-size: 0.75rem; color: #64748b;">
+                © 2024 NinjaCross. Alle Rechte vorbehalten.
+            </p>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/public/email-templates/reauthentication.txt b/public/email-templates/reauthentication.txt
new file mode 100644
index 0000000..95229b8
--- /dev/null
+++ b/public/email-templates/reauthentication.txt
@@ -0,0 +1,30 @@
+🥷 NINJACROSS - Die ultimative Timer-Rangliste
+================================================
+
+Erneute Authentifizierung erforderlich 🔒
+
+Für diese Aktion ist eine erneute Authentifizierung erforderlich. 
+Klicke auf den Link unten, um deine Identität zu bestätigen.
+
+🛡️ Identität bestätigen:
+{{ .ConfirmationURL }}
+
+🔒 Warum ist das nötig?
+Bestimmte Aktionen wie das Ändern sensibler Daten oder das Zugreifen auf 
+administrative Funktionen erfordern eine erneute Authentifizierung, 
+um die Sicherheit deines Kontos zu gewährleisten.
+
+⏰ Zeitlimit:
+Dieser Link verfällt nach 15 Minuten. Falls du diese Aktion nicht 
+angefordert hast, kannst du diese E-Mail ignorieren.
+
+================================================
+
+Falls du diese Aktion nicht angefordert hast, kannst du diese E-Mail ignorieren.
+
+Links:
+- Zur Website: {{ .SiteURL }}
+- Support: {{ .SiteURL }}/support
+- Datenschutz: {{ .SiteURL }}/privacy
+
+© 2024 NinjaCross. Alle Rechte vorbehalten.
diff --git a/public/email-templates/reset-password-compatible.html b/public/email-templates/reset-password-compatible.html
new file mode 100644
index 0000000..034e949
--- /dev/null
+++ b/public/email-templates/reset-password-compatible.html
@@ -0,0 +1,249 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Passwort zurücksetzen - NinjaCross</title>
+    <style>
+        /* E-Mail-Client-kompatible Styles */
+        body {
+            font-family: Arial, sans-serif;
+            background-color: #0a0a0f;
+            color: #ffffff;
+            margin: 0;
+            padding: 20px;
+            line-height: 1.6;
+        }
+        
+        .email-container {
+            max-width: 600px;
+            margin: 0 auto;
+            background-color: #1e293b;
+            border: 2px solid #334155;
+            border-radius: 15px;
+            overflow: hidden;
+        }
+        
+        .email-header {
+            background-color: #00d4ff;
+            padding: 30px 20px;
+            text-align: center;
+        }
+        
+        .logo {
+            font-size: 28px;
+            font-weight: bold;
+            color: #ffffff;
+            margin-bottom: 5px;
+        }
+        
+        .tagline {
+            color: #e2e8f0;
+            font-size: 14px;
+        }
+        
+        .email-content {
+            padding: 30px 20px;
+            background-color: #1e293b;
+        }
+        
+        .reset-title {
+            font-size: 24px;
+            font-weight: bold;
+            color: #e2e8f0;
+            text-align: center;
+            margin-bottom: 20px;
+        }
+        
+        .reset-message {
+            color: #cbd5e1;
+            font-size: 16px;
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        
+        .reset-info {
+            background-color: #334155;
+            border: 1px solid #475569;
+            border-radius: 10px;
+            padding: 20px;
+            margin-bottom: 30px;
+            text-align: center;
+        }
+        
+        .reset-icon {
+            font-size: 40px;
+            margin-bottom: 10px;
+            display: block;
+        }
+        
+        .reset-description {
+            color: #94a3b8;
+            font-size: 14px;
+        }
+        
+        .cta-button {
+            display: block;
+            width: 100%;
+            max-width: 300px;
+            margin: 0 auto 30px;
+            padding: 15px 30px;
+            background-color: #00d4ff;
+            color: #ffffff;
+            text-decoration: none;
+            border-radius: 10px;
+            font-weight: bold;
+            font-size: 16px;
+            text-align: center;
+            text-transform: uppercase;
+        }
+        
+        .security-tips {
+            background-color: #22c55e;
+            border: 1px solid #16a34a;
+            border-radius: 10px;
+            padding: 20px;
+            margin-top: 30px;
+        }
+        
+        .security-title {
+            color: #ffffff;
+            font-weight: bold;
+            font-size: 16px;
+            margin-bottom: 15px;
+            text-align: center;
+        }
+        
+        .security-list {
+            color: #ffffff;
+            font-size: 14px;
+            line-height: 1.8;
+        }
+        
+        .security-list li {
+            margin-bottom: 8px;
+        }
+        
+        .warning-info {
+            background-color: #ef4444;
+            border: 1px solid #dc2626;
+            border-radius: 10px;
+            padding: 15px;
+            margin-top: 20px;
+        }
+        
+        .warning-title {
+            color: #ffffff;
+            font-weight: bold;
+            font-size: 14px;
+            margin-bottom: 8px;
+            text-align: center;
+        }
+        
+        .warning-text {
+            color: #ffffff;
+            font-size: 13px;
+            text-align: center;
+        }
+        
+        .email-footer {
+            background-color: #0f172a;
+            padding: 20px;
+            text-align: center;
+            color: #64748b;
+            font-size: 12px;
+        }
+        
+        .footer a {
+            color: #00d4ff;
+            text-decoration: none;
+            margin: 0 10px;
+        }
+        
+        /* Mobile Responsive */
+        @media (max-width: 600px) {
+            .email-container {
+                margin: 0 10px;
+            }
+            
+            .email-content {
+                padding: 20px 15px;
+            }
+            
+            .logo {
+                font-size: 24px;
+            }
+            
+            .reset-title {
+                font-size: 20px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="email-container">
+        <!-- Header -->
+        <div class="email-header">
+            <div class="logo">🥷 NINJACROSS</div>
+            <div class="tagline">Die ultimative Timer-Rangliste</div>
+        </div>
+        
+        <!-- Content -->
+        <div class="email-content">
+            <h1 class="reset-title">Passwort zurücksetzen 🔐</h1>
+            
+            <p class="reset-message">
+                Du hast eine Anfrage zum Zurücksetzen deines Passworts gestellt. 
+                Klicke auf den Button unten, um ein neues Passwort zu erstellen.
+            </p>
+            
+            <div class="reset-info">
+                <span class="reset-icon">🔑</span>
+                <div class="reset-description">
+                    Dieser Link ist sicher und führt dich zur Passwort-Reset-Seite
+                </div>
+            </div>
+            
+            <a href="{{ .ConfirmationURL }}" class="cta-button">
+                🔄 Passwort zurücksetzen
+            </a>
+            
+            <div class="security-tips">
+                <div class="security-title">🛡️ Tipps für ein sicheres Passwort:</div>
+                <ul class="security-list">
+                    <li>• Verwende mindestens 8 Zeichen</li>
+                    <li>• Kombiniere Groß- und Kleinbuchstaben</li>
+                    <li>• Füge Zahlen und Sonderzeichen hinzu</li>
+                    <li>• Verwende keine persönlichen Informationen</li>
+                    <li>• Nutze ein einzigartiges Passwort nur für NinjaCross</li>
+                </ul>
+            </div>
+            
+            <div class="warning-info">
+                <div class="warning-title">⚠️ Sicherheitshinweis</div>
+                <div class="warning-text">
+                    Dieser Link verfällt nach 24 Stunden. Falls du diese Anfrage nicht gestellt hast, 
+                    kannst du diese E-Mail ignorieren.
+                </div>
+            </div>
+        </div>
+        
+        <!-- Footer -->
+        <div class="email-footer">
+            <p>
+                Falls du diese Anfrage nicht gestellt hast, kannst du diese E-Mail ignorieren.
+            </p>
+            
+            <p style="margin-top: 15px;">
+                <a href="{{ .SiteURL }}">Zur Website</a>
+                <a href="{{ .SiteURL }}/support">Support</a>
+                <a href="{{ .SiteURL }}/privacy">Datenschutz</a>
+            </p>
+            
+            <p style="margin-top: 15px;">
+                © 2024 NinjaCross. Alle Rechte vorbehalten.
+            </p>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/public/email-templates/reset-password-optimized.html b/public/email-templates/reset-password-optimized.html
new file mode 100644
index 0000000..ee78e4f
--- /dev/null
+++ b/public/email-templates/reset-password-optimized.html
@@ -0,0 +1,301 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Passwort zurücksetzen - NinjaCross</title>
+    <!--[if mso]>
+    <noscript>
+        <xml>
+            <o:OfficeDocumentSettings>
+                <o:PixelsPerInch>96</o:PixelsPerInch>
+            </o:OfficeDocumentSettings>
+        </xml>
+    </noscript>
+    <![endif]-->
+    <style type="text/css">
+        /* Reset styles for email clients */
+        body, table, td, p, a, li, blockquote {
+            -webkit-text-size-adjust: 100%;
+            -ms-text-size-adjust: 100%;
+        }
+        table, td {
+            mso-table-lspace: 0pt;
+            mso-table-rspace: 0pt;
+        }
+        img {
+            -ms-interpolation-mode: bicubic;
+            border: 0;
+            height: auto;
+            line-height: 100%;
+            outline: none;
+            text-decoration: none;
+        }
+        
+        /* Main styles */
+        body {
+            font-family: Arial, sans-serif;
+            background-color: #0a0a0f;
+            color: #ffffff;
+            margin: 0;
+            padding: 0;
+            line-height: 1.6;
+        }
+        
+        .email-wrapper {
+            width: 100%;
+            background-color: #0a0a0f;
+            padding: 20px 0;
+        }
+        
+        .email-container {
+            max-width: 600px;
+            margin: 0 auto;
+            background-color: #1e293b;
+            border: 2px solid #334155;
+        }
+        
+        .email-header {
+            background-color: #00d4ff;
+            padding: 30px 20px;
+            text-align: center;
+        }
+        
+        .logo {
+            font-size: 28px;
+            font-weight: bold;
+            color: #ffffff;
+            margin: 0 0 5px 0;
+        }
+        
+        .tagline {
+            color: #e2e8f0;
+            font-size: 14px;
+            margin: 0;
+        }
+        
+        .email-content {
+            padding: 30px 20px;
+            background-color: #1e293b;
+        }
+        
+        .reset-title {
+            font-size: 24px;
+            font-weight: bold;
+            color: #ffffff;
+            text-align: center;
+            margin: 0 0 20px 0;
+        }
+        
+        .reset-message {
+            color: #cbd5e1;
+            font-size: 16px;
+            text-align: center;
+            margin: 0 0 30px 0;
+        }
+        
+        .reset-info {
+            background-color: #334155;
+            border: 1px solid #475569;
+            padding: 20px;
+            margin: 0 0 30px 0;
+            text-align: center;
+        }
+        
+        .reset-icon {
+            font-size: 40px;
+            margin: 0 0 10px 0;
+            display: block;
+        }
+        
+        .reset-description {
+            color: #94a3b8;
+            font-size: 14px;
+            margin: 0;
+        }
+        
+        .cta-button {
+            display: block;
+            width: 100%;
+            max-width: 300px;
+            margin: 0 auto 30px;
+            padding: 15px 30px;
+            background-color: #00d4ff;
+            color: #ffffff;
+            text-decoration: none;
+            font-weight: bold;
+            font-size: 16px;
+            text-align: center;
+            text-transform: uppercase;
+        }
+        
+        .cta-button:hover {
+            background-color: #0891b2;
+        }
+        
+        .security-tips {
+            background-color: #22c55e;
+            border: 1px solid #16a34a;
+            padding: 20px;
+            margin: 30px 0 0 0;
+        }
+        
+        .security-title {
+            color: #ffffff;
+            font-weight: bold;
+            font-size: 16px;
+            margin: 0 0 15px 0;
+            text-align: center;
+        }
+        
+        .security-list {
+            color: #ffffff;
+            font-size: 14px;
+            line-height: 1.8;
+            margin: 0;
+            padding: 0;
+        }
+        
+        .security-list li {
+            margin: 0 0 8px 0;
+            list-style: none;
+        }
+        
+        .warning-info {
+            background-color: #ef4444;
+            border: 1px solid #dc2626;
+            padding: 15px;
+            margin: 20px 0 0 0;
+        }
+        
+        .warning-title {
+            color: #ffffff;
+            font-weight: bold;
+            font-size: 14px;
+            margin: 0 0 8px 0;
+            text-align: center;
+        }
+        
+        .warning-text {
+            color: #ffffff;
+            font-size: 13px;
+            text-align: center;
+            margin: 0;
+        }
+        
+        .email-footer {
+            background-color: #0f172a;
+            padding: 20px;
+            text-align: center;
+            color: #64748b;
+            font-size: 12px;
+        }
+        
+        .footer a {
+            color: #00d4ff;
+            text-decoration: none;
+            margin: 0 10px;
+        }
+        
+        .footer a:hover {
+            color: #0891b2;
+        }
+        
+        /* Mobile styles */
+        @media only screen and (max-width: 600px) {
+            .email-wrapper {
+                padding: 10px 0;
+            }
+            
+            .email-container {
+                margin: 0 10px;
+            }
+            
+            .email-content {
+                padding: 20px 15px;
+            }
+            
+            .logo {
+                font-size: 24px;
+            }
+            
+            .reset-title {
+                font-size: 20px;
+            }
+            
+            .cta-button {
+                padding: 12px 20px;
+                font-size: 14px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="email-wrapper">
+        <div class="email-container">
+            <!-- Header -->
+            <div class="email-header">
+                <div class="logo">🥷 NINJACROSS</div>
+                <div class="tagline">Die ultimative Timer-Rangliste</div>
+            </div>
+            
+            <!-- Content -->
+            <div class="email-content">
+                <h1 class="reset-title">Passwort zurücksetzen 🔐</h1>
+                
+                <p class="reset-message">
+                    Du hast eine Anfrage zum Zurücksetzen deines Passworts gestellt. 
+                    Klicke auf den Button unten, um ein neues Passwort zu erstellen.
+                </p>
+                
+                <div class="reset-info">
+                    <span class="reset-icon">🔑</span>
+                    <div class="reset-description">
+                        Dieser Link ist sicher und führt dich zur Passwort-Reset-Seite
+                    </div>
+                </div>
+                
+                <a href="{{ .ConfirmationURL }}" class="cta-button">
+                    🔄 Passwort zurücksetzen
+                </a>
+                
+                <div class="security-tips">
+                    <div class="security-title">🛡️ Tipps für ein sicheres Passwort:</div>
+                    <ul class="security-list">
+                        <li>• Verwende mindestens 8 Zeichen</li>
+                        <li>• Kombiniere Groß- und Kleinbuchstaben</li>
+                        <li>• Füge Zahlen und Sonderzeichen hinzu</li>
+                        <li>• Verwende keine persönlichen Informationen</li>
+                        <li>• Nutze ein einzigartiges Passwort nur für NinjaCross</li>
+                    </ul>
+                </div>
+                
+                <div class="warning-info">
+                    <div class="warning-title">⚠️ Sicherheitshinweis</div>
+                    <div class="warning-text">
+                        Dieser Link verfällt nach 24 Stunden. Falls du diese Anfrage nicht gestellt hast, 
+                        kannst du diese E-Mail ignorieren.
+                    </div>
+                </div>
+            </div>
+            
+            <!-- Footer -->
+            <div class="email-footer">
+                <p>
+                    Falls du diese Anfrage nicht gestellt hast, kannst du diese E-Mail ignorieren.
+                </p>
+                
+                <p style="margin-top: 15px;">
+                    <a href="https://ninja.reptilfpv.de:3000">Zur Website</a>
+                    <a href="https://ninja.reptilfpv.de:3000/support">Support</a>
+                    <a href="https://ninja.reptilfpv.de:3000/privacy">Datenschutz</a>
+                </p>
+                
+                <p style="margin-top: 15px;">
+                    © 2024 NinjaCross. Alle Rechte vorbehalten.
+                </p>
+            </div>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/public/email-templates/reset-password-table.html b/public/email-templates/reset-password-table.html
new file mode 100644
index 0000000..e67df29
--- /dev/null
+++ b/public/email-templates/reset-password-table.html
@@ -0,0 +1,323 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Passwort zurücksetzen - NinjaCross</title>
+    <!--[if mso]>
+    <noscript>
+        <xml>
+            <o:OfficeDocumentSettings>
+                <o:PixelsPerInch>96</o:PixelsPerInch>
+            </o:OfficeDocumentSettings>
+        </xml>
+    </noscript>
+    <![endif]-->
+    <style type="text/css">
+        /* Reset styles */
+        body, table, td, p, a, li, blockquote {
+            -webkit-text-size-adjust: 100%;
+            -ms-text-size-adjust: 100%;
+        }
+        table, td {
+            mso-table-lspace: 0pt;
+            mso-table-rspace: 0pt;
+        }
+        img {
+            -ms-interpolation-mode: bicubic;
+            border: 0;
+            height: auto;
+            line-height: 100%;
+            outline: none;
+            text-decoration: none;
+        }
+        
+        /* Main styles */
+        body {
+            font-family: Arial, sans-serif;
+            background-color: #0a0a0f;
+            color: #ffffff;
+            margin: 0;
+            padding: 0;
+            line-height: 1.6;
+        }
+        
+        .email-wrapper {
+            width: 100%;
+            background-color: #0a0a0f;
+            padding: 20px 0;
+        }
+        
+        .email-container {
+            max-width: 600px;
+            margin: 0 auto;
+            background-color: #1e293b;
+            border: 2px solid #334155;
+        }
+        
+        .email-header {
+            background-color: #00d4ff;
+            padding: 30px 20px;
+            text-align: center;
+        }
+        
+        .logo {
+            font-size: 28px;
+            font-weight: bold;
+            color: #ffffff;
+            margin: 0 0 5px 0;
+        }
+        
+        .tagline {
+            color: #e2e8f0;
+            font-size: 14px;
+            margin: 0;
+        }
+        
+        .email-content {
+            padding: 30px 20px;
+            background-color: #1e293b;
+        }
+        
+        .reset-title {
+            font-size: 24px;
+            font-weight: bold;
+            color: #ffffff;
+            text-align: center;
+            margin: 0 0 20px 0;
+        }
+        
+        .reset-message {
+            color: #cbd5e1;
+            font-size: 16px;
+            text-align: center;
+            margin: 0 0 30px 0;
+        }
+        
+        .reset-info {
+            background-color: #334155;
+            border: 1px solid #475569;
+            padding: 20px;
+            margin: 0 0 30px 0;
+            text-align: center;
+        }
+        
+        .reset-icon {
+            font-size: 40px;
+            margin: 0 0 10px 0;
+            display: block;
+        }
+        
+        .reset-description {
+            color: #94a3b8;
+            font-size: 14px;
+            margin: 0;
+        }
+        
+        .cta-button {
+            display: block;
+            width: 100%;
+            max-width: 300px;
+            margin: 0 auto 30px;
+            padding: 15px 30px;
+            background-color: #00d4ff;
+            color: #ffffff;
+            text-decoration: none;
+            font-weight: bold;
+            font-size: 16px;
+            text-align: center;
+            text-transform: uppercase;
+        }
+        
+        .security-tips {
+            background-color: #22c55e;
+            border: 1px solid #16a34a;
+            padding: 20px;
+            margin: 30px 0 0 0;
+        }
+        
+        .security-title {
+            color: #ffffff;
+            font-weight: bold;
+            font-size: 16px;
+            margin: 0 0 15px 0;
+            text-align: center;
+        }
+        
+        .security-list {
+            color: #ffffff;
+            font-size: 14px;
+            line-height: 1.8;
+            margin: 0;
+            padding: 0;
+        }
+        
+        .security-list li {
+            margin: 0 0 8px 0;
+            list-style: none;
+        }
+        
+        .warning-info {
+            background-color: #ef4444;
+            border: 1px solid #dc2626;
+            padding: 15px;
+            margin: 20px 0 0 0;
+        }
+        
+        .warning-title {
+            color: #ffffff;
+            font-weight: bold;
+            font-size: 14px;
+            margin: 0 0 8px 0;
+            text-align: center;
+        }
+        
+        .warning-text {
+            color: #ffffff;
+            font-size: 13px;
+            text-align: center;
+            margin: 0;
+        }
+        
+        .email-footer {
+            background-color: #0f172a;
+            padding: 20px;
+            text-align: center;
+            color: #64748b;
+            font-size: 12px;
+        }
+        
+        .footer a {
+            color: #00d4ff;
+            text-decoration: none;
+            margin: 0 10px;
+        }
+        
+        /* Mobile styles */
+        @media only screen and (max-width: 600px) {
+            .email-wrapper {
+                padding: 10px 0;
+            }
+            
+            .email-container {
+                margin: 0 10px;
+            }
+            
+            .email-content {
+                padding: 20px 15px;
+            }
+            
+            .logo {
+                font-size: 24px;
+            }
+            
+            .reset-title {
+                font-size: 20px;
+            }
+            
+            .cta-button {
+                padding: 12px 20px;
+                font-size: 14px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="email-wrapper">
+        <table width="100%" cellpadding="0" cellspacing="0" border="0" style="background-color: #0a0a0f;">
+            <tr>
+                <td align="center" style="padding: 20px 0;">
+                    <table width="600" cellpadding="0" cellspacing="0" border="0" style="background-color: #1e293b; border: 2px solid #334155; max-width: 600px;">
+                        <!-- Header -->
+                        <tr>
+                            <td style="background-color: #00d4ff; padding: 30px 20px; text-align: center;">
+                                <div class="logo">🥷 NINJACROSS</div>
+                                <div class="tagline">Die ultimative Timer-Rangliste</div>
+                            </td>
+                        </tr>
+                        
+                        <!-- Content -->
+                        <tr>
+                            <td style="padding: 30px 20px; background-color: #1e293b;">
+                                <h1 class="reset-title">Passwort zurücksetzen 🔐</h1>
+                                
+                                <p class="reset-message">
+                                    Du hast eine Anfrage zum Zurücksetzen deines Passworts gestellt. 
+                                    Klicke auf den Button unten, um ein neues Passwort zu erstellen.
+                                </p>
+                                
+                                <table width="100%" cellpadding="0" cellspacing="0" border="0" style="background-color: #334155; border: 1px solid #475569; margin: 0 0 30px 0;">
+                                    <tr>
+                                        <td style="padding: 20px; text-align: center;">
+                                            <span class="reset-icon">🔑</span>
+                                            <div class="reset-description">
+                                                Dieser Link ist sicher und führt dich zur Passwort-Reset-Seite
+                                            </div>
+                                        </td>
+                                    </tr>
+                                </table>
+                                
+                                <table width="100%" cellpadding="0" cellspacing="0" border="0" style="margin: 0 0 30px 0;">
+                                    <tr>
+                                        <td align="center">
+                                            <a href="{{ .ConfirmationURL }}" class="cta-button">
+                                                🔄 Passwort zurücksetzen
+                                            </a>
+                                        </td>
+                                    </tr>
+                                </table>
+                                
+                                <table width="100%" cellpadding="0" cellspacing="0" border="0" style="background-color: #22c55e; border: 1px solid #16a34a; margin: 30px 0 0 0;">
+                                    <tr>
+                                        <td style="padding: 20px;">
+                                            <div class="security-title">🛡️ Tipps für ein sicheres Passwort:</div>
+                                            <ul class="security-list">
+                                                <li>• Verwende mindestens 8 Zeichen</li>
+                                                <li>• Kombiniere Groß- und Kleinbuchstaben</li>
+                                                <li>• Füge Zahlen und Sonderzeichen hinzu</li>
+                                                <li>• Verwende keine persönlichen Informationen</li>
+                                                <li>• Nutze ein einzigartiges Passwort nur für NinjaCross</li>
+                                            </ul>
+                                        </td>
+                                    </tr>
+                                </table>
+                                
+                                <table width="100%" cellpadding="0" cellspacing="0" border="0" style="background-color: #ef4444; border: 1px solid #dc2626; margin: 20px 0 0 0;">
+                                    <tr>
+                                        <td style="padding: 15px;">
+                                            <div class="warning-title">⚠️ Sicherheitshinweis</div>
+                                            <div class="warning-text">
+                                                Dieser Link verfällt nach 24 Stunden. Falls du diese Anfrage nicht gestellt hast, 
+                                                kannst du diese E-Mail ignorieren.
+                                            </div>
+                                        </td>
+                                    </tr>
+                                </table>
+                            </td>
+                        </tr>
+                        
+                        <!-- Footer -->
+                        <tr>
+                            <td style="background-color: #0f172a; padding: 20px; text-align: center; color: #64748b; font-size: 12px;">
+                                <p>
+                                    Falls du diese Anfrage nicht gestellt hast, kannst du diese E-Mail ignorieren.
+                                </p>
+                                
+                                <p style="margin-top: 15px;">
+                                    <a href="https://ninja.reptilfpv.de:3000" style="color: #00d4ff; text-decoration: none; margin: 0 10px;">Zur Website</a>
+                                    <a href="https://ninja.reptilfpv.de:3000/support" style="color: #00d4ff; text-decoration: none; margin: 0 10px;">Support</a>
+                                    <a href="https://ninja.reptilfpv.de:3000/privacy" style="color: #00d4ff; text-decoration: none; margin: 0 10px;">Datenschutz</a>
+                                </p>
+                                
+                                <p style="margin-top: 15px;">
+                                    © 2024 NinjaCross. Alle Rechte vorbehalten.
+                                </p>
+                            </td>
+                        </tr>
+                    </table>
+                </td>
+            </tr>
+        </table>
+    </div>
+</body>
+</html>
diff --git a/public/email-templates/reset-password.html b/public/email-templates/reset-password.html
new file mode 100644
index 0000000..8291350
--- /dev/null
+++ b/public/email-templates/reset-password.html
@@ -0,0 +1,294 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Passwort zurücksetzen - NinjaCross</title>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Inter', sans-serif;
+            background: #0a0a0f;
+            color: #ffffff;
+            line-height: 1.6;
+            margin: 0;
+            padding: 0;
+        }
+        
+        .email-container {
+            max-width: 600px;
+            margin: 0 auto;
+            background: #0a0a0f;
+            background-image: 
+                radial-gradient(circle at 20% 80%, #1a1a2e 0%, transparent 50%),
+                radial-gradient(circle at 80% 20%, #16213e 0%, transparent 50%),
+                radial-gradient(circle at 40% 40%, #0f3460 0%, transparent 50%);
+        }
+        
+        .email-header {
+            text-align: center;
+            padding: 3rem 2rem 2rem;
+        }
+        
+        .logo {
+            font-size: 2.5rem;
+            font-weight: 700;
+            background: linear-gradient(135deg, #00d4ff, #ff6b35, #ffd700);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            margin-bottom: 0.5rem;
+            letter-spacing: -0.02em;
+        }
+        
+        .tagline {
+            color: #94a3b8;
+            font-size: 1rem;
+            font-weight: 400;
+        }
+        
+        .email-content {
+            background: rgba(30, 41, 59, 0.95);
+            backdrop-filter: blur(20px);
+            border: 1px solid rgba(51, 65, 85, 0.3);
+            margin: 0 2rem;
+            padding: 2.5rem;
+            border-radius: 1.5rem;
+            box-shadow: 
+                0 25px 50px rgba(0, 0, 0, 0.3),
+                0 0 0 1px rgba(0, 212, 255, 0.1);
+        }
+        
+        .reset-title {
+            font-size: 1.75rem;
+            font-weight: 600;
+            color: #e2e8f0;
+            text-align: center;
+            margin-bottom: 1.5rem;
+        }
+        
+        .reset-message {
+            color: #cbd5e1;
+            font-size: 1rem;
+            margin-bottom: 2rem;
+            text-align: center;
+        }
+        
+        .reset-info {
+            background: rgba(51, 65, 85, 0.3);
+            border: 1px solid rgba(0, 212, 255, 0.1);
+            border-radius: 0.75rem;
+            padding: 1.5rem;
+            margin-bottom: 2rem;
+            text-align: center;
+        }
+        
+        .reset-icon {
+            font-size: 3rem;
+            margin-bottom: 1rem;
+            display: block;
+        }
+        
+        .reset-description {
+            color: #94a3b8;
+            font-size: 0.9rem;
+            margin-bottom: 1rem;
+        }
+        
+        .cta-button {
+            display: inline-block;
+            width: 100%;
+            padding: 1rem 2rem;
+            background: linear-gradient(135deg, #00d4ff, #0891b2);
+            color: white;
+            text-decoration: none;
+            border-radius: 0.75rem;
+            font-weight: 600;
+            font-size: 1rem;
+            text-align: center;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            box-shadow: 0 4px 12px rgba(0, 212, 255, 0.3);
+            transition: all 0.2s ease;
+            margin-bottom: 2rem;
+        }
+        
+        .cta-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 16px rgba(0, 212, 255, 0.4);
+        }
+        
+        .security-tips {
+            background: rgba(34, 197, 94, 0.1);
+            border: 1px solid rgba(34, 197, 94, 0.3);
+            border-radius: 0.75rem;
+            padding: 1.5rem;
+            margin-top: 2rem;
+        }
+        
+        .security-title {
+            color: #22c55e;
+            font-weight: 600;
+            font-size: 1rem;
+            margin-bottom: 1rem;
+            text-align: center;
+        }
+        
+        .security-list {
+            color: #86efac;
+            font-size: 0.9rem;
+            line-height: 1.8;
+        }
+        
+        .security-list li {
+            margin-bottom: 0.5rem;
+        }
+        
+        .warning-info {
+            background: rgba(239, 68, 68, 0.1);
+            border: 1px solid rgba(239, 68, 68, 0.3);
+            border-radius: 0.75rem;
+            padding: 1rem;
+            margin-top: 1.5rem;
+        }
+        
+        .warning-title {
+            color: #ef4444;
+            font-weight: 600;
+            font-size: 0.9rem;
+            margin-bottom: 0.5rem;
+            text-align: center;
+        }
+        
+        .warning-text {
+            color: #fca5a5;
+            font-size: 0.85rem;
+            text-align: center;
+        }
+        
+        .email-footer {
+            text-align: center;
+            padding: 2rem;
+            color: #64748b;
+            font-size: 0.875rem;
+        }
+        
+        .footer-links {
+            margin-top: 1rem;
+        }
+        
+        .footer-links a {
+            color: #00d4ff;
+            text-decoration: none;
+            margin: 0 1rem;
+        }
+        
+        .footer-links a:hover {
+            color: #0891b2;
+        }
+        
+        .divider {
+            height: 1px;
+            background: linear-gradient(90deg, transparent, #334155, transparent);
+            margin: 2rem 0;
+        }
+        
+        /* Mobile Responsive */
+        @media (max-width: 600px) {
+            .email-content {
+                margin: 0 1rem;
+                padding: 2rem;
+            }
+            
+            .email-header {
+                padding: 2rem 1rem 1rem;
+            }
+            
+            .logo {
+                font-size: 2rem;
+            }
+            
+            .reset-title {
+                font-size: 1.5rem;
+            }
+            
+            .reset-icon {
+                font-size: 2.5rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="email-container">
+        <!-- Header -->
+        <div class="email-header">
+            <div class="logo">🥷 NINJACROSS</div>
+            <div class="tagline">Die ultimative Timer-Rangliste</div>
+        </div>
+        
+        <!-- Main Content -->
+        <div class="email-content">
+            <h1 class="reset-title">Passwort zurücksetzen 🔐</h1>
+            
+            <p class="reset-message">
+                Du hast eine Anfrage zum Zurücksetzen deines Passworts gestellt. 
+                Klicke auf den Button unten, um ein neues Passwort zu erstellen.
+            </p>
+            
+            <div class="reset-info">
+                <span class="reset-icon">🔑</span>
+                <div class="reset-description">
+                    Dieser Link ist sicher und führt dich zur Passwort-Reset-Seite
+                </div>
+            </div>
+            
+            <a href="{{ .ConfirmationURL }}" class="cta-button">
+                🔄 Passwort zurücksetzen
+            </a>
+            
+            <div class="security-tips">
+                <div class="security-title">🛡️ Tipps für ein sicheres Passwort:</div>
+                <ul class="security-list">
+                    <li>• Verwende mindestens 8 Zeichen</li>
+                    <li>• Kombiniere Groß- und Kleinbuchstaben</li>
+                    <li>• Füge Zahlen und Sonderzeichen hinzu</li>
+                    <li>• Verwende keine persönlichen Informationen</li>
+                    <li>• Nutze ein einzigartiges Passwort nur für NinjaCross</li>
+                </ul>
+            </div>
+            
+            <div class="warning-info">
+                <div class="warning-title">⚠️ Sicherheitshinweis</div>
+                <div class="warning-text">
+                    Dieser Link verfällt nach 24 Stunden. Falls du diese Anfrage nicht gestellt hast, 
+                    kannst du diese E-Mail ignorieren.
+                </div>
+            </div>
+        </div>
+        
+        <!-- Footer -->
+        <div class="email-footer">
+            <p>
+                Falls du diese Anfrage nicht gestellt hast, kannst du diese E-Mail ignorieren.
+            </p>
+            
+            <div class="footer-links">
+                <a href="{{ .SiteURL }}">Zur Website</a>
+                <a href="{{ .SiteURL }}/support">Support</a>
+                <a href="{{ .SiteURL }}/privacy">Datenschutz</a>
+            </div>
+            
+            <p style="margin-top: 1.5rem; font-size: 0.75rem; color: #64748b;">
+                © 2024 NinjaCross. Alle Rechte vorbehalten.
+            </p>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/public/email-templates/reset-password.txt b/public/email-templates/reset-password.txt
new file mode 100644
index 0000000..019032f
--- /dev/null
+++ b/public/email-templates/reset-password.txt
@@ -0,0 +1,32 @@
+🥷 NINJACROSS - Die ultimative Timer-Rangliste
+================================================
+
+Passwort zurücksetzen 🔐
+
+Du hast eine Anfrage zum Zurücksetzen deines Passworts gestellt. 
+Klicke auf den Link unten, um ein neues Passwort zu erstellen.
+
+🔑 Passwort zurücksetzen:
+{{ .ConfirmationURL }}
+
+🛡️ Tipps für ein sicheres Passwort:
+• Verwende mindestens 8 Zeichen
+• Kombiniere Groß- und Kleinbuchstaben
+• Füge Zahlen und Sonderzeichen hinzu
+• Verwende keine persönlichen Informationen
+• Nutze ein einzigartiges Passwort nur für NinjaCross
+
+⚠️ Sicherheitshinweis:
+Dieser Link verfällt nach 24 Stunden. Falls du diese Anfrage nicht gestellt hast, 
+kannst du diese E-Mail ignorieren.
+
+================================================
+
+Falls du diese Anfrage nicht gestellt hast, kannst du diese E-Mail ignorieren.
+
+Links:
+- Zur Website: {{ .SiteURL }}
+- Support: {{ .SiteURL }}/support
+- Datenschutz: {{ .SiteURL }}/privacy
+
+© 2024 NinjaCross. Alle Rechte vorbehalten.
diff --git a/public/email-templates/welcome-email-compatible.html b/public/email-templates/welcome-email-compatible.html
new file mode 100644
index 0000000..3bf9b1a
--- /dev/null
+++ b/public/email-templates/welcome-email-compatible.html
@@ -0,0 +1,208 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Willkommen bei NinjaCross</title>
+    <style>
+        /* E-Mail-Client-kompatible Styles */
+        body {
+            font-family: Arial, sans-serif;
+            background-color: #0a0a0f;
+            color: #ffffff;
+            margin: 0;
+            padding: 20px;
+            line-height: 1.6;
+        }
+        
+        .email-container {
+            max-width: 600px;
+            margin: 0 auto;
+            background-color: #1e293b;
+            border: 2px solid #334155;
+            border-radius: 15px;
+            overflow: hidden;
+        }
+        
+        .email-header {
+            background-color: #00d4ff;
+            padding: 30px 20px;
+            text-align: center;
+        }
+        
+        .logo {
+            font-size: 28px;
+            font-weight: bold;
+            color: #ffffff;
+            margin-bottom: 5px;
+        }
+        
+        .tagline {
+            color: #e2e8f0;
+            font-size: 14px;
+        }
+        
+        .email-content {
+            padding: 30px 20px;
+            background-color: #1e293b;
+        }
+        
+        .welcome-title {
+            font-size: 24px;
+            font-weight: bold;
+            color: #e2e8f0;
+            text-align: center;
+            margin-bottom: 20px;
+        }
+        
+        .welcome-message {
+            color: #cbd5e1;
+            font-size: 16px;
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        
+        .cta-button {
+            display: block;
+            width: 100%;
+            max-width: 300px;
+            margin: 0 auto 30px;
+            padding: 15px 30px;
+            background-color: #00d4ff;
+            color: #ffffff;
+            text-decoration: none;
+            border-radius: 10px;
+            font-weight: bold;
+            font-size: 16px;
+            text-align: center;
+            text-transform: uppercase;
+        }
+        
+        .features {
+            margin-top: 30px;
+        }
+        
+        .feature {
+            background-color: #334155;
+            border: 1px solid #475569;
+            border-radius: 10px;
+            padding: 15px;
+            margin-bottom: 15px;
+        }
+        
+        .feature-icon {
+            font-size: 20px;
+            margin-right: 10px;
+        }
+        
+        .feature-text {
+            color: #cbd5e1;
+            font-size: 14px;
+        }
+        
+        .email-footer {
+            background-color: #0f172a;
+            padding: 20px;
+            text-align: center;
+            color: #64748b;
+            font-size: 12px;
+        }
+        
+        .footer a {
+            color: #00d4ff;
+            text-decoration: none;
+            margin: 0 10px;
+        }
+        
+        /* Mobile Responsive */
+        @media (max-width: 600px) {
+            .email-container {
+                margin: 0 10px;
+            }
+            
+            .email-content {
+                padding: 20px 15px;
+            }
+            
+            .logo {
+                font-size: 24px;
+            }
+            
+            .welcome-title {
+                font-size: 20px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="email-container">
+        <!-- Header -->
+        <div class="email-header">
+            <div class="logo">🥷 NINJACROSS</div>
+            <div class="tagline">Die ultimative Timer-Rangliste</div>
+        </div>
+        
+        <!-- Content -->
+        <div class="email-content">
+            <h1 class="welcome-title">Willkommen bei NinjaCross! 🎉</h1>
+            
+            <p class="welcome-message">
+                Vielen Dank für deine Registrierung! Du bist jetzt Teil der NinjaCross-Community. 
+                Bestätige deine E-Mail-Adresse, um dein Konto zu aktivieren und sofort loszulegen.
+            </p>
+            
+            <a href="{{ .ConfirmationURL }}" class="cta-button">
+                ✉️ E-Mail bestätigen
+            </a>
+            
+            <!-- Features -->
+            <div class="features">
+                <div class="feature">
+                    <span class="feature-icon">🏃‍♂️</span>
+                    <span class="feature-text">
+                        <strong>Timer-Tracking:</strong> Erfasse deine Zeiten und verfolge deinen Fortschritt
+                    </span>
+                </div>
+                
+                <div class="feature">
+                    <span class="feature-icon">🏆</span>
+                    <span class="feature-text">
+                        <strong>Leaderboards:</strong> Vergleiche dich mit anderen Spielern und erreiche die Spitze
+                    </span>
+                </div>
+                
+                <div class="feature">
+                    <span class="feature-icon">📊</span>
+                    <span class="feature-text">
+                        <strong>Statistiken:</strong> Detaillierte Analysen deiner Performance und Verbesserungen
+                    </span>
+                </div>
+                
+                <div class="feature">
+                    <span class="feature-icon">🌍</span>
+                    <span class="feature-text">
+                        <strong>Multi-Location:</strong> Spiele an verschiedenen Standorten und sammle Erfahrungen
+                    </span>
+                </div>
+            </div>
+        </div>
+        
+        <!-- Footer -->
+        <div class="email-footer">
+            <p>
+                Falls du dich nicht registriert hast, kannst du diese E-Mail ignorieren.
+            </p>
+            
+            <p style="margin-top: 15px;">
+                <a href="{{ .SiteURL }}">Zur Website</a>
+                <a href="{{ .SiteURL }}/support">Support</a>
+                <a href="{{ .SiteURL }}/privacy">Datenschutz</a>
+            </p>
+            
+            <p style="margin-top: 15px;">
+                © 2024 NinjaCross. Alle Rechte vorbehalten.
+            </p>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/public/email-templates/welcome-email-simple.html b/public/email-templates/welcome-email-simple.html
new file mode 100644
index 0000000..afd724e
--- /dev/null
+++ b/public/email-templates/welcome-email-simple.html
@@ -0,0 +1,187 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Willkommen bei NinjaCross</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            background-color: #0a0a0f;
+            color: #ffffff;
+            margin: 0;
+            padding: 20px;
+            line-height: 1.6;
+        }
+        
+        .container {
+            max-width: 600px;
+            margin: 0 auto;
+            background-color: #1e293b;
+            border: 2px solid #334155;
+            border-radius: 15px;
+            overflow: hidden;
+        }
+        
+        .header {
+            background: linear-gradient(135deg, #00d4ff, #0891b2);
+            padding: 30px 20px;
+            text-align: center;
+        }
+        
+        .logo {
+            font-size: 28px;
+            font-weight: bold;
+            color: #ffffff;
+            margin-bottom: 5px;
+        }
+        
+        .tagline {
+            color: #e2e8f0;
+            font-size: 14px;
+        }
+        
+        .content {
+            padding: 30px 20px;
+        }
+        
+        .title {
+            font-size: 24px;
+            font-weight: bold;
+            color: #e2e8f0;
+            text-align: center;
+            margin-bottom: 20px;
+        }
+        
+        .message {
+            color: #cbd5e1;
+            font-size: 16px;
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        
+        .button {
+            display: block;
+            width: 100%;
+            max-width: 300px;
+            margin: 0 auto 30px;
+            padding: 15px 30px;
+            background: linear-gradient(135deg, #00d4ff, #0891b2);
+            color: #ffffff;
+            text-decoration: none;
+            border-radius: 10px;
+            font-weight: bold;
+            font-size: 16px;
+            text-align: center;
+            text-transform: uppercase;
+        }
+        
+        .features {
+            margin-top: 30px;
+        }
+        
+        .feature {
+            background-color: #334155;
+            border: 1px solid #475569;
+            border-radius: 10px;
+            padding: 15px;
+            margin-bottom: 15px;
+        }
+        
+        .feature-icon {
+            font-size: 20px;
+            margin-right: 10px;
+        }
+        
+        .feature-text {
+            color: #cbd5e1;
+            font-size: 14px;
+        }
+        
+        .footer {
+            background-color: #0f172a;
+            padding: 20px;
+            text-align: center;
+            color: #64748b;
+            font-size: 12px;
+        }
+        
+        .footer a {
+            color: #00d4ff;
+            text-decoration: none;
+            margin: 0 10px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <!-- Header -->
+        <div class="header">
+            <div class="logo">🥷 NINJACROSS</div>
+            <div class="tagline">Die ultimative Timer-Rangliste</div>
+        </div>
+        
+        <!-- Content -->
+        <div class="content">
+            <h1 class="title">Willkommen bei NinjaCross! 🎉</h1>
+            
+            <p class="message">
+                Vielen Dank für deine Registrierung! Du bist jetzt Teil der NinjaCross-Community. 
+                Bestätige deine E-Mail-Adresse, um dein Konto zu aktivieren und sofort loszulegen.
+            </p>
+            
+            <a href="{{ .ConfirmationURL }}" class="button">
+                ✉️ E-Mail bestätigen
+            </a>
+            
+            <!-- Features -->
+            <div class="features">
+                <div class="feature">
+                    <span class="feature-icon">🏃‍♂️</span>
+                    <span class="feature-text">
+                        <strong>Timer-Tracking:</strong> Erfasse deine Zeiten und verfolge deinen Fortschritt
+                    </span>
+                </div>
+                
+                <div class="feature">
+                    <span class="feature-icon">🏆</span>
+                    <span class="feature-text">
+                        <strong>Leaderboards:</strong> Vergleiche dich mit anderen Spielern und erreiche die Spitze
+                    </span>
+                </div>
+                
+                <div class="feature">
+                    <span class="feature-icon">📊</span>
+                    <span class="feature-text">
+                        <strong>Statistiken:</strong> Detaillierte Analysen deiner Performance und Verbesserungen
+                    </span>
+                </div>
+                
+                <div class="feature">
+                    <span class="feature-icon">🌍</span>
+                    <span class="feature-text">
+                        <strong>Multi-Location:</strong> Spiele an verschiedenen Standorten und sammle Erfahrungen
+                    </span>
+                </div>
+            </div>
+        </div>
+        
+        <!-- Footer -->
+        <div class="footer">
+            <p>
+                Falls du dich nicht registriert hast, kannst du diese E-Mail ignorieren.
+            </p>
+            
+            <p style="margin-top: 15px;">
+                <a href="{{ .SiteURL }}">Zur Website</a>
+                <a href="{{ .SiteURL }}/support">Support</a>
+                <a href="{{ .SiteURL }}/privacy">Datenschutz</a>
+            </p>
+            
+            <p style="margin-top: 15px;">
+                © 2024 NinjaCross. Alle Rechte vorbehalten.
+            </p>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/public/email-templates/welcome-email.html b/public/email-templates/welcome-email.html
new file mode 100644
index 0000000..4486863
--- /dev/null
+++ b/public/email-templates/welcome-email.html
@@ -0,0 +1,274 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Willkommen bei NinjaCross</title>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Inter', sans-serif;
+            background: #0a0a0f;
+            color: #ffffff;
+            line-height: 1.6;
+            margin: 0;
+            padding: 0;
+        }
+        
+        .email-container {
+            max-width: 600px;
+            margin: 0 auto;
+            background: #0a0a0f;
+            background-image: 
+                radial-gradient(circle at 20% 80%, #1a1a2e 0%, transparent 50%),
+                radial-gradient(circle at 80% 20%, #16213e 0%, transparent 50%),
+                radial-gradient(circle at 40% 40%, #0f3460 0%, transparent 50%);
+        }
+        
+        .email-header {
+            text-align: center;
+            padding: 3rem 2rem 2rem;
+        }
+        
+        .logo {
+            font-size: 2.5rem;
+            font-weight: 700;
+            background: linear-gradient(135deg, #00d4ff, #ff6b35, #ffd700);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            margin-bottom: 0.5rem;
+            letter-spacing: -0.02em;
+        }
+        
+        .tagline {
+            color: #94a3b8;
+            font-size: 1rem;
+            font-weight: 400;
+        }
+        
+        .email-content {
+            background: rgba(30, 41, 59, 0.95);
+            backdrop-filter: blur(20px);
+            border: 1px solid rgba(51, 65, 85, 0.3);
+            margin: 0 2rem;
+            padding: 2.5rem;
+            border-radius: 1.5rem;
+            box-shadow: 
+                0 25px 50px rgba(0, 0, 0, 0.3),
+                0 0 0 1px rgba(0, 212, 255, 0.1);
+        }
+        
+        .welcome-title {
+            font-size: 1.75rem;
+            font-weight: 600;
+            color: #e2e8f0;
+            text-align: center;
+            margin-bottom: 1.5rem;
+        }
+        
+        .welcome-message {
+            color: #cbd5e1;
+            font-size: 1rem;
+            margin-bottom: 2rem;
+            text-align: center;
+        }
+        
+        .cta-button {
+            display: inline-block;
+            width: 100%;
+            padding: 1rem 2rem;
+            background: linear-gradient(135deg, #00d4ff, #0891b2);
+            color: white;
+            text-decoration: none;
+            border-radius: 0.75rem;
+            font-weight: 600;
+            font-size: 1rem;
+            text-align: center;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            box-shadow: 0 4px 12px rgba(0, 212, 255, 0.3);
+            transition: all 0.2s ease;
+            margin-bottom: 2rem;
+        }
+        
+        .cta-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 16px rgba(0, 212, 255, 0.4);
+        }
+        
+        .features-section {
+            margin-top: 2rem;
+        }
+        
+        .features-title {
+            font-size: 1.25rem;
+            font-weight: 600;
+            color: #e2e8f0;
+            margin-bottom: 1rem;
+            text-align: center;
+        }
+        
+        .feature-item {
+            display: flex;
+            align-items: center;
+            margin-bottom: 1rem;
+            padding: 1rem;
+            background: rgba(51, 65, 85, 0.3);
+            border-radius: 0.75rem;
+            border: 1px solid rgba(0, 212, 255, 0.1);
+        }
+        
+        .feature-icon {
+            font-size: 1.5rem;
+            margin-right: 1rem;
+            width: 2rem;
+            text-align: center;
+        }
+        
+        .feature-text {
+            color: #cbd5e1;
+            font-size: 0.95rem;
+        }
+        
+        .email-footer {
+            text-align: center;
+            padding: 2rem;
+            color: #64748b;
+            font-size: 0.875rem;
+        }
+        
+        .footer-links {
+            margin-top: 1rem;
+        }
+        
+        .footer-links a {
+            color: #00d4ff;
+            text-decoration: none;
+            margin: 0 1rem;
+        }
+        
+        .footer-links a:hover {
+            color: #0891b2;
+        }
+        
+        .divider {
+            height: 1px;
+            background: linear-gradient(90deg, transparent, #334155, transparent);
+            margin: 2rem 0;
+        }
+        
+        /* Mobile Responsive */
+        @media (max-width: 600px) {
+            .email-content {
+                margin: 0 1rem;
+                padding: 2rem;
+            }
+            
+            .email-header {
+                padding: 2rem 1rem 1rem;
+            }
+            
+            .logo {
+                font-size: 2rem;
+            }
+            
+            .welcome-title {
+                font-size: 1.5rem;
+            }
+            
+            .feature-item {
+                flex-direction: column;
+                text-align: center;
+            }
+            
+            .feature-icon {
+                margin-right: 0;
+                margin-bottom: 0.5rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="email-container">
+        <!-- Header -->
+        <div class="email-header">
+            <div class="logo">🥷 NINJACROSS</div>
+            <div class="tagline">Die ultimative Timer-Rangliste</div>
+        </div>
+        
+        <!-- Main Content -->
+        <div class="email-content">
+            <h1 class="welcome-title">Willkommen bei NinjaCross! 🎉</h1>
+            
+            <p class="welcome-message">
+                Vielen Dank für deine Registrierung! Du bist jetzt Teil der NinjaCross-Community. 
+                Bestätige deine E-Mail-Adresse, um dein Konto zu aktivieren und sofort loszulegen.
+            </p>
+            
+            <a href="{{ .ConfirmationURL }}" class="cta-button">
+                ✉️ E-Mail bestätigen
+            </a>
+            
+            <div class="divider"></div>
+            
+            <!-- Features Section -->
+            <div class="features-section">
+                <h2 class="features-title">Was dich erwartet:</h2>
+                
+                <div class="feature-item">
+                    <div class="feature-icon">🏃‍♂️</div>
+                    <div class="feature-text">
+                        <strong>Timer-Tracking:</strong> Erfasse deine Zeiten und verfolge deinen Fortschritt
+                    </div>
+                </div>
+                
+                <div class="feature-item">
+                    <div class="feature-icon">🏆</div>
+                    <div class="feature-text">
+                        <strong>Leaderboards:</strong> Vergleiche dich mit anderen Spielern und erreiche die Spitze
+                    </div>
+                </div>
+                
+                <div class="feature-item">
+                    <div class="feature-icon">📊</div>
+                    <div class="feature-text">
+                        <strong>Statistiken:</strong> Detaillierte Analysen deiner Performance und Verbesserungen
+                    </div>
+                </div>
+                
+                <div class="feature-item">
+                    <div class="feature-icon">🌍</div>
+                    <div class="feature-text">
+                        <strong>Multi-Location:</strong> Spiele an verschiedenen Standorten und sammle Erfahrungen
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <!-- Footer -->
+        <div class="email-footer">
+            <p>
+                Falls du dich nicht registriert hast, kannst du diese E-Mail ignorieren.
+            </p>
+            
+            <div class="footer-links">
+                <a href="{{ .SiteURL }}">Zur Website</a>
+                <a href="{{ .SiteURL }}/support">Support</a>
+                <a href="{{ .SiteURL }}/privacy">Datenschutz</a>
+            </div>
+            
+            <p style="margin-top: 1.5rem; font-size: 0.75rem; color: #64748b;">
+                © 2024 NinjaCross. Alle Rechte vorbehalten.
+            </p>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/public/email-templates/welcome-email.txt b/public/email-templates/welcome-email.txt
new file mode 100644
index 0000000..83f4466
--- /dev/null
+++ b/public/email-templates/welcome-email.txt
@@ -0,0 +1,32 @@
+🥷 NINJACROSS - Die ultimative Timer-Rangliste
+================================================
+
+Willkommen bei NinjaCross! 🎉
+
+Vielen Dank für deine Registrierung! Du bist jetzt Teil der NinjaCross-Community. 
+Bestätige deine E-Mail-Adresse, um dein Konto zu aktivieren und sofort loszulegen.
+
+📧 E-Mail bestätigen:
+{{ .ConfirmationURL }}
+
+Was dich erwartet:
+==================
+
+🏃‍♂️ Timer-Tracking: Erfasse deine Zeiten und verfolge deinen Fortschritt
+
+🏆 Leaderboards: Vergleiche dich mit anderen Spielern und erreiche die Spitze
+
+📊 Statistiken: Detaillierte Analysen deiner Performance und Verbesserungen
+
+🌍 Multi-Location: Spiele an verschiedenen Standorten und sammle Erfahrungen
+
+================================================
+
+Falls du dich nicht registriert hast, kannst du diese E-Mail ignorieren.
+
+Links:
+- Zur Website: {{ .SiteURL }}
+- Support: {{ .SiteURL }}/support
+- Datenschutz: {{ .SiteURL }}/privacy
+
+© 2024 NinjaCross. Alle Rechte vorbehalten.
diff --git a/public/generator.html b/public/generator.html
new file mode 100644
index 0000000..85244c8
--- /dev/null
+++ b/public/generator.html
@@ -0,0 +1,85 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Lizenzgenerator</title>
+    <link rel="icon" type="image/x-icon" href="/pictures/favicon.ico">
+    <link rel="stylesheet" href="/css/generator.css">
+</head>
+<body>
+    <div class="container">
+        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 20px;">
+            <h1 style="margin: 0;">🔐 Lizenzgenerator</h1>
+            <div style="display: flex; gap: 10px;">
+                <button onclick="goBackToDashboard()" style="padding: 10px 20px; background: #2196f3; color: white; border: none; border-radius: 8px; cursor: pointer; font-weight: 500; transition: all 0.3s ease;">⬅️ Zurück zum Dashboard</button>
+                <button onclick="logout()" style="padding: 10px 20px; background: #f44336; color: white; border: none; border-radius: 8px; cursor: pointer; font-weight: 500; transition: all 0.3s ease;">🚪 Abmelden</button>
+            </div>
+        </div>
+        
+        <form id="licenseForm" onsubmit="generateLicense(); return false;">
+            <div class="form-group">
+                <label for="mac">MAC-Adresse</label>
+                <input type="text" id="mac" name="mac" placeholder="00:1A:2B:3C:4D:5E" required>
+            </div>
+
+            <div class="form-group">
+                <label for="tier">Lizenzstufe</label>
+                <input type="number" id="tier" name="tier" min="1" max="4" value="1" required>
+            </div>
+
+            <div id="dbConfig" class="db-config">
+                <!-- Token-Felder werden hier dynamisch eingefügt -->
+            </div>
+
+            <button type="submit" class="generate-btn" id="generateBtn">
+                <span id="btn-text">Lizenz generieren</span>
+            </button>
+        </form>
+
+        <div id="result" class="result-section">
+            <div class="license-label">Generierter Lizenzschlüssel:</div>
+            <div class="license-output" id="license-output"></div>
+            <button class="copy-btn" id="copyButton" onclick="copyToClipboard()">📋 In Zwischenablage kopieren</button>
+        </div>
+
+        <div id="success" class="success"></div>
+        <div id="error" class="error"></div>
+
+        <div class="info-text">
+            Der Lizenzgenerator erstellt sichere API-Token für verschiedene Zugriffsstufen.
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-content">
+            <div class="footer-links">
+                <a href="/impressum.html" class="footer-link">Impressum</a>
+                <a href="/datenschutz.html" class="footer-link">Datenschutz</a>
+                <button id="cookie-settings-footer" class="footer-link cookie-settings-btn">Cookie-Einstellungen</button>
+            </div>
+            <div class="footer-text">
+                <p>&copy; 2024 NinjaCross. Alle Rechte vorbehalten.</p>
+            </div>
+        </div>
+    </footer>
+
+    <script src="/js/cookie-consent.js"></script>
+    <script src="/js/generator.js"></script>
+    <script>
+        // Verhindert Enter-Taste in Eingabefeldern
+        document.addEventListener('DOMContentLoaded', function() {
+            const inputs = document.querySelectorAll('input, textarea');
+            inputs.forEach(input => {
+                input.addEventListener('keydown', function(e) {
+                    if (e.key === 'Enter') {
+                        e.preventDefault();
+                        return false;
+                    }
+                });
+            });
+        });
+    </script>
+</body>
+</html>
diff --git a/public/impressum.html b/public/impressum.html
new file mode 100644
index 0000000..3b40762
--- /dev/null
+++ b/public/impressum.html
@@ -0,0 +1,241 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Impressum - NinjaCross</title>
+    <link rel="icon" type="image/x-icon" href="/pictures/favicon.ico">
+    <link rel="stylesheet" href="/css/leaderboard.css">
+    <style>
+        .legal-container {
+            max-width: 1000px;
+            margin: 0 auto;
+            padding: 2rem;
+            min-height: 100vh;
+        }
+
+        .legal-header {
+            text-align: center;
+            margin-bottom: 3rem;
+        }
+
+        .legal-title {
+            font-size: 3.5rem;
+            font-weight: 700;
+            background: linear-gradient(135deg, #00d4ff, #ff6b35, #ffd700);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            margin-bottom: 0.5rem;
+            letter-spacing: -0.02em;
+        }
+
+        .legal-subtitle {
+            font-size: 1.2rem;
+            color: #8892b0;
+            font-weight: 300;
+        }
+
+        .legal-content {
+            background: rgba(30, 41, 59, 0.8);
+            backdrop-filter: blur(20px);
+            border: 1px solid rgba(51, 65, 85, 0.3);
+            border-radius: 20px;
+            padding: 3rem;
+            box-shadow: 0 20px 40px rgba(0, 0, 0, 0.3);
+        }
+
+        .section {
+            margin-bottom: 2.5rem;
+        }
+
+        .section h2 {
+            color: #00d4ff;
+            font-size: 1.8rem;
+            margin-bottom: 1rem;
+            border-bottom: 2px solid #334155;
+            padding-bottom: 0.5rem;
+            font-weight: 600;
+        }
+
+        .section h3 {
+            color: #ff6b35;
+            font-size: 1.3rem;
+            margin: 1.5rem 0 0.8rem 0;
+            font-weight: 500;
+        }
+
+        .section p, .section li {
+            margin-bottom: 0.8rem;
+            color: #e2e8f0;
+            line-height: 1.6;
+        }
+
+        .section ul {
+            margin-left: 1.5rem;
+        }
+
+        .contact-info {
+            background: rgba(0, 212, 255, 0.1);
+            border: 1px solid rgba(0, 212, 255, 0.3);
+            padding: 1.5rem;
+            border-radius: 12px;
+            margin: 1rem 0;
+        }
+
+        .contact-info p {
+            margin-bottom: 0.5rem;
+        }
+
+        .contact-info strong {
+            color: #00d4ff;
+        }
+
+        .back-button {
+            display: inline-flex;
+            align-items: center;
+            gap: 0.5rem;
+            background: linear-gradient(135deg, #00d4ff, #0099cc);
+            color: white;
+            padding: 12px 24px;
+            text-decoration: none;
+            border-radius: 12px;
+            margin-top: 2rem;
+            font-weight: 600;
+            transition: all 0.3s ease;
+            box-shadow: 0 4px 15px rgba(0, 212, 255, 0.3);
+        }
+
+        .back-button:hover {
+            background: linear-gradient(135deg, #0099cc, #007aa3);
+            transform: translateY(-2px);
+            box-shadow: 0 8px 25px rgba(0, 212, 255, 0.4);
+        }
+
+        .highlight-box {
+            background: rgba(255, 107, 53, 0.1);
+            border: 1px solid rgba(255, 107, 53, 0.3);
+            padding: 1.5rem;
+            border-radius: 12px;
+            margin: 1.5rem 0;
+        }
+
+        .highlight-box h3 {
+            color: #ff6b35;
+            margin-top: 0;
+        }
+
+        .highlight-box p {
+            color: #e2e8f0;
+            margin: 0;
+        }
+
+        @media (max-width: 768px) {
+            .legal-container {
+                padding: 1rem;
+            }
+            
+            .legal-content {
+                padding: 1.5rem;
+            }
+            
+            .legal-title {
+                font-size: 2.5rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="legal-container">
+        <div class="legal-header">
+            <h1 class="legal-title">🏃‍♂️ Impressum</h1>
+            <p class="legal-subtitle">NinjaCross - Speedrun Arena</p>
+        </div>
+        
+        <div class="legal-content">
+            <div class="section">
+                <h2>Angaben gemäß § 5 TMG</h2>
+                <div class="contact-info">
+                    <p><strong>Betreiber der Website:</strong></p>
+                    <p>Carsten Graf<br>
+                    Erfurter Str. 20<br>
+                    75365 Calw<br>
+                    Deutschland</p>
+                    
+                    <p><strong>Kontakt:</strong></p>
+                    <p>Telefon: +49 (0) 123 456789<br>
+                    E-Mail: reptil1990(at)me.com</p>
+                </div>
+            </div>
+
+            <div class="section">
+                <h2>Verantwortlich für den Inhalt nach § 55 Abs. 2 RStV</h2>
+                <p>Carsten Graf<br>
+                    Erfurter Str. 20<br>
+                    75365 Calw<br>
+                    Deutschland</p>
+            </div>
+
+            <div class="section">
+                <h2>Haftung für Inhalte</h2>
+                <p>Als Diensteanbieter sind wir gemäß § 7 Abs.1 TMG für eigene Inhalte auf diesen Seiten nach den allgemeinen Gesetzen verantwortlich. Nach §§ 8 bis 10 TMG sind wir als Diensteanbieter jedoch nicht unter der Verpflichtung, übermittelte oder gespeicherte fremde Informationen zu überwachen oder nach Umständen zu forschen, die auf eine rechtswidrige Tätigkeit hinweisen.</p>
+                
+                <p>Verpflichtungen zur Entfernung oder Sperrung der Nutzung von Informationen nach den allgemeinen Gesetzen bleiben hiervon unberührt. Eine diesbezügliche Haftung ist jedoch erst ab dem Zeitpunkt der Kenntnis einer konkreten Rechtsverletzung möglich. Bei Bekanntwerden von entsprechenden Rechtsverletzungen werden wir diese Inhalte umgehend entfernen.</p>
+            </div>
+
+            <div class="section">
+                <h2>Haftung für Links</h2>
+                <p>Unser Angebot enthält Links zu externen Websites Dritter, auf deren Inhalte wir keinen Einfluss haben. Deshalb können wir für diese fremden Inhalte auch keine Gewähr übernehmen. Für die Inhalte der verlinkten Seiten ist stets der jeweilige Anbieter oder Betreiber der Seiten verantwortlich. Die verlinkten Seiten wurden zum Zeitpunkt der Verlinkung auf mögliche Rechtsverstöße überprüft. Rechtswidrige Inhalte waren zum Zeitpunkt der Verlinkung nicht erkennbar.</p>
+                
+                <p>Eine permanente inhaltliche Kontrolle der verlinkten Seiten ist jedoch ohne konkrete Anhaltspunkte einer Rechtsverletzung nicht zumutbar. Bei Bekanntwerden von Rechtsverletzungen werden wir derartige Links umgehend entfernen.</p>
+            </div>
+
+            <div class="section">
+                <h2>Urheberrecht</h2>
+                <p>Die durch die Seitenbetreiber erstellten Inhalte und Werke auf diesen Seiten unterliegen dem deutschen Urheberrecht. Die Vervielfältigung, Bearbeitung, Verbreitung und jede Art der Verwertung außerhalb der Grenzen des Urheberrechtes bedürfen der schriftlichen Zustimmung des jeweiligen Autors bzw. Erstellers. Downloads und Kopien dieser Seite sind nur für den privaten, nicht kommerziellen Gebrauch gestattet.</p>
+                
+                <p>Soweit die Inhalte auf dieser Seite nicht vom Betreiber erstellt wurden, werden die Urheberrechte Dritter beachtet. Insbesondere werden Inhalte Dritter als solche gekennzeichnet. Sollten Sie trotzdem auf eine Urheberrechtsverletzung aufmerksam werden, bitten wir um einen entsprechenden Hinweis. Bei Bekanntwerden von Rechtsverletzungen werden wir derartige Inhalte umgehend entfernen.</p>
+            </div>
+
+            <div class="section">
+                <h2>Streitschlichtung</h2>
+                <p>Die Europäische Kommission stellt eine Plattform zur Online-Streitbeilegung (OS) bereit: <a href="https://ec.europa.eu/consumers/odr/" target="_blank" rel="noopener">https://ec.europa.eu/consumers/odr/</a></p>
+                <p>Unsere E-Mail-Adresse finden Sie oben im Impressum.</p>
+                <p>Wir sind nicht bereit oder verpflichtet, an Streitbeilegungsverfahren vor einer Verbraucherschlichtungsstelle teilzunehmen.</p>
+            </div>
+
+
+            <a href="/" class="back-button">← Zurück zur Startseite</a>
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-content">
+            <div class="footer-links">
+                <a href="/impressum.html" class="footer-link">Impressum</a>
+                <a href="/datenschutz.html" class="footer-link">Datenschutz</a>
+                <button id="cookie-settings-footer" class="footer-link cookie-settings-btn">Cookie-Einstellungen</button>
+            </div>
+            <div class="footer-text">
+                <p>&copy; 2024 NinjaCross. Alle Rechte vorbehalten.</p>
+            </div>
+        </div>
+    </footer>
+
+    <script src="/js/cookie-consent.js"></script>
+    <script>
+        // Add cookie settings button functionality
+        document.addEventListener('DOMContentLoaded', function() {
+            const cookieSettingsBtn = document.getElementById('cookie-settings-footer');
+            if (cookieSettingsBtn) {
+                cookieSettingsBtn.addEventListener('click', function() {
+                    if (window.cookieConsent) {
+                        window.cookieConsent.resetConsent();
+                    }
+                });
+            }
+        });
+    </script>
+</body>
+</html>
diff --git a/public/index.html b/public/index.html
new file mode 100644
index 0000000..008ee84
--- /dev/null
+++ b/public/index.html
@@ -0,0 +1,262 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Timer Leaderboard</title>
+    <link rel="icon" type="image/x-icon" href="/pictures/favicon.ico">
+    <script src="/js/page-tracking.js"></script>
+    <script src="/js/cookie-utils.js"></script>
+    <link rel="stylesheet" href="/css/index.css">
+</head>
+<body>
+    <!-- Notification Bubble -->
+    <div class="notification-bubble" id="notificationBubble">
+        <div class="notification-content">
+            <div class="notification-icon">🏁</div>
+            <div class="notification-text">
+                <div class="notification-title" id="notificationTitle" data-de="Neue Zeit!" data-en="New Time!">New Time!</div>
+                <div class="notification-subtitle" id="notificationSubtitle" data-de="Ein neuer Rekord wurde erstellt" data-en="A new record has been created">A new record has been created</div>
+            </div>
+        </div>
+    </div>
+
+    <div class="main-container">
+        <!-- Sticky Header Container -->
+        <div class="sticky-header">
+            <!-- Language Selector -->
+            <div class="language-selector">
+                <select id="languageSelect" onchange="changeLanguage()">
+                    <option value="de" data-flag="🇩🇪">Deutsch</option>
+                    <option value="en" data-flag="🇺🇸">English</option>
+                </select>
+            </div>
+
+            <!-- Admin Login Button -->
+            <div class="mobile-nav-buttons">
+                <a href="/login" class="admin-login-btn" id="adminLoginBtn" onclick="handleLoginClick(event)">🔐 Login</a>
+                <a href="/dashboard" class="dashboard-btn" id="dashboardBtn" style="display: none;">📊 Dashboard</a>
+                <button class="logout-btn" id="logoutBtn" onclick="logout()" style="display: none;">🚪 Logout</button>
+            </div>
+        </div>
+
+        <div class="header-section">
+            <h1 class="main-title">NINJACROSS LEADERBOARD</h1>
+            <p class="tagline" data-de="Die ultimative NinjaCross-Rangliste" data-en="The ultimate NinjaCross leaderboard">The ultimate NinjaCross leaderboard</p>
+        </div>
+
+        <div class="dashboard-grid">
+            <div class="control-panel">
+                <div class="control-group">
+                    <label class="control-label" data-de="Standort" data-en="Location">Location</label>
+                    <div class="location-control">
+                        <select class="custom-select location-select" id="locationSelect">
+                            <option value="">📍 Please select location</option>
+                            <!-- Locations are loaded dynamically -->
+                        </select>
+                        <button class="location-btn" id="findLocationBtn" onclick="findNearestLocation()" title="Find nearest location" data-de="📍 Mein Standort" data-en="📍 My Location">
+                            📍 My Location
+                        </button>
+                    </div>
+                </div>
+
+                <div class="control-group">
+                    <label class="control-label" data-de="Zeitraum" data-en="Time Period">Time Period</label>
+                    <div class="time-tabs">
+                        <button class="time-tab" data-period="today">
+                            <span class="tab-icon">📅</span>
+                            <span class="tab-text" data-de="Heute" data-en="Today">Today</span>
+                        </button>
+                        <button class="time-tab" data-period="week">
+                            <span class="tab-icon">📊</span>
+                            <span class="tab-text" data-de="Diese Woche" data-en="This Week">This Week</span>
+                        </button>
+                        <button class="time-tab" data-period="month">
+                            <span class="tab-icon">📈</span>
+                            <span class="tab-text" data-de="Dieser Monat" data-en="This Month">This Month</span>
+                        </button>
+                        <button class="time-tab active" data-period="all">
+                            <span class="tab-icon">♾️</span>
+                            <span class="tab-text" data-de="Alle Zeiten" data-en="All Times">All Times</span>
+                        </button>
+                    </div>
+                </div>
+
+                <button class="refresh-btn pulse-animation" onclick="loadData()" data-de="⚡ Live Update" data-en="⚡ Live Update">
+                    ⚡ Live Update
+                </button>
+            </div>
+
+            <div class="stats-panel">
+                <div class="stats-grid">
+                    <div class="stat-card">
+                        <div class="stat-value" id="totalPlayers">0</div>
+                        <div class="stat-label" data-de="Teilnehmer" data-en="Participants">Participants</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="stat-value" id="bestTime">--:--</div>
+                        <div class="stat-label" data-de="Rekordzeit" data-en="Record Time">Record Time</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="stat-value" id="totalRecords">0</div>
+                        <div class="stat-label" data-de="Läufe" data-en="Runs">Runs</div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <div class="leaderboard-container">
+            <div class="leaderboard-header">
+                <div class="active-filters" id="currentSelection">
+                    📍 Please select location • ♾️ All Times
+                </div>
+                <div class="last-sync" id="lastUpdated">
+                    Last Sync: Loading...
+                </div>
+            </div>
+            
+            <div class="rankings-list" id="rankingList">
+                <!-- Rankings will be inserted here -->
+            </div>
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-content">
+            <div class="footer-links">
+                <a href="/impressum.html" class="footer-link" data-de="Impressum" data-en="Imprint">Imprint</a>
+                <a href="/datenschutz.html" class="footer-link" data-de="Datenschutz" data-en="Privacy">Privacy</a>
+                <button id="cookie-settings-footer" class="footer-link cookie-settings-btn" data-de="Cookie-Einstellungen" data-en="Cookie Settings">Cookie Settings</button>
+            </div>
+            <div class="footer-text">
+                <p data-de="&copy; 2024 NinjaCross. Alle Rechte vorbehalten." data-en="&copy; 2024 NinjaCross. All rights reserved.">&copy; 2024 NinjaCross. All rights reserved.</p>
+            </div>
+        </div>
+    </footer>
+
+    <!-- External Libraries -->
+    <script src="https://unpkg.com/@supabase/supabase-js@2"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.8.1/socket.io.min.js"></script>
+    
+    <!-- Application JavaScript -->
+    <script src="/js/cookie-consent.js"></script>
+    <script src="/js/index.js"></script>
+    
+    <script>
+        // iOS Detection
+        function isIOS() {
+            return /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
+        }
+        
+        // Mobile Sticky Header Fix
+        function initMobileStickyHeader() {
+            const stickyHeader = document.querySelector('.sticky-header');
+            if (!stickyHeader) return;
+            
+            // Check if we're on mobile
+            const isMobile = window.innerWidth <= 768;
+            
+            if (isMobile || isIOS()) {
+                // Force fixed positioning for mobile
+                stickyHeader.style.position = 'fixed';
+                stickyHeader.style.top = '0';
+                stickyHeader.style.left = '0';
+                stickyHeader.style.right = '0';
+                stickyHeader.style.width = '100%';
+                stickyHeader.style.zIndex = '99999';
+                stickyHeader.style.marginBottom = '0';
+                stickyHeader.style.borderRadius = '0';
+                
+                // Add padding to main container
+                const mainContainer = document.querySelector('.main-container');
+                if (mainContainer) {
+                    mainContainer.style.paddingTop = '80px';
+                }
+                
+                console.log('Mobile sticky header fix applied');
+            }
+        }
+        
+        // iOS Touch Event Fix
+        function handleLoginClick(event) {
+            console.log('Login button clicked');
+            
+            // Prevent default behavior temporarily
+            event.preventDefault();
+            
+            // Add visual feedback
+            const button = event.target;
+            button.style.transform = 'scale(0.95)';
+            button.style.opacity = '0.8';
+            
+            // Reset after short delay
+            setTimeout(() => {
+                button.style.transform = '';
+                button.style.opacity = '';
+                
+                // Navigate to login page
+                window.location.href = '/login';
+            }, 150);
+        }
+        
+        // Add touch event listeners for better mobile support
+        document.addEventListener('DOMContentLoaded', function() {
+            // Initialize mobile sticky header
+            initMobileStickyHeader();
+            
+            const loginBtn = document.getElementById('adminLoginBtn');
+            if (loginBtn) {
+                // Make sure button is clickable
+                loginBtn.style.pointerEvents = 'auto';
+                loginBtn.style.position = 'relative';
+                loginBtn.style.zIndex = '100000';
+                
+                // Add multiple event listeners for maximum compatibility
+                loginBtn.addEventListener('touchstart', function(e) {
+                    console.log('Touch start on login button');
+                    e.preventDefault();
+                    this.style.transform = 'scale(0.95)';
+                    this.style.opacity = '0.8';
+                }, { passive: false });
+                
+                loginBtn.addEventListener('touchend', function(e) {
+                    console.log('Touch end on login button');
+                    e.preventDefault();
+                    e.stopPropagation();
+                    setTimeout(() => {
+                        this.style.transform = '';
+                        this.style.opacity = '';
+                        window.location.href = '/login';
+                    }, 100);
+                }, { passive: false });
+                
+                loginBtn.addEventListener('click', function(e) {
+                    console.log('Click on login button');
+                    e.preventDefault();
+                    e.stopPropagation();
+                    window.location.href = '/login';
+                });
+                
+                // Add mousedown for desktop
+                loginBtn.addEventListener('mousedown', function(e) {
+                    console.log('Mouse down on login button');
+                    this.style.transform = 'scale(0.95)';
+                    this.style.opacity = '0.8';
+                });
+                
+                loginBtn.addEventListener('mouseup', function(e) {
+                    console.log('Mouse up on login button');
+                    this.style.transform = '';
+                    this.style.opacity = '';
+                });
+            }
+        });
+        
+        // Re-apply mobile fixes on window resize
+        window.addEventListener('resize', function() {
+            setTimeout(initMobileStickyHeader, 100);
+        });
+    </script>
+</body>
+</html>
diff --git a/public/js/admin-dashboard.js b/public/js/admin-dashboard.js
new file mode 100644
index 0000000..5f99405
--- /dev/null
+++ b/public/js/admin-dashboard.js
@@ -0,0 +1,1768 @@
+let currentUser = null;
+let currentDataType = null;
+let currentData = [];
+
+// Beim Laden der Seite
+document.addEventListener('DOMContentLoaded', function () {
+    checkAuth();
+    loadStatistics();
+
+    // Add cookie settings button functionality
+    const cookieSettingsBtn = document.getElementById('cookie-settings-footer');
+    if (cookieSettingsBtn) {
+        cookieSettingsBtn.addEventListener('click', function () {
+            if (window.cookieConsent) {
+                window.cookieConsent.resetConsent();
+            }
+        });
+    }
+    loadPageStatistics();
+    setupEventListeners();
+});
+
+function setupEventListeners() {
+    // Logout Button
+    document.getElementById('logoutBtn').addEventListener('click', logout);
+
+    // Generator Button
+    document.getElementById('generatorBtn').addEventListener('click', function () {
+        window.location.href = '/generator';
+    });
+
+    // Modal Close Buttons
+    document.querySelectorAll('.close').forEach(closeBtn => {
+        closeBtn.addEventListener('click', closeModal);
+    });
+
+    // Confirm Modal Buttons
+    document.getElementById('confirmNo').addEventListener('click', closeModal);
+
+    // Search Input
+    document.getElementById('searchInput').addEventListener('input', filterData);
+
+    // Add Form
+    document.getElementById('addForm').addEventListener('submit', handleAddSubmit);
+}
+
+async function checkAuth() {
+    try {
+        const response = await fetch('/api/v1/web/check-session');
+        const result = await response.json();
+
+        if (!result.success) {
+            window.location.href = '/adminlogin.html';
+            return;
+        }
+
+        currentUser = result.user;
+        document.getElementById('username').textContent = currentUser.username;
+
+        const accessBadge = document.getElementById('accessBadge');
+        accessBadge.textContent = `Level ${currentUser.access_level}`;
+        accessBadge.className = `access-badge level-${currentUser.access_level}`;
+
+        // Generator-Button nur für Level 2
+        if (currentUser.access_level >= 2) {
+            document.getElementById('generatorBtn').style.display = 'inline-block';
+        }
+
+    } catch (error) {
+        console.error('Auth check failed:', error);
+        window.location.href = '/adminlogin.html';
+    }
+}
+
+async function logout() {
+    try {
+        await fetch('/api/v1/public/logout', { method: 'POST' });
+        window.location.href = '/adminlogin.html';
+    } catch (error) {
+        console.error('Logout failed:', error);
+        window.location.href = '/adminlogin.html';
+    }
+}
+
+async function loadStatistics() {
+    try {
+        const response = await fetch('/api/v1/admin/stats');
+        const stats = await response.json();
+
+        if (stats.success) {
+            document.getElementById('totalPlayers').textContent = stats.data.players || 0;
+            document.getElementById('totalRuns').textContent = stats.data.runs || 0;
+            document.getElementById('totalLocations').textContent = stats.data.locations || 0;
+            document.getElementById('totalAdminUsers').textContent = stats.data.adminUsers || 0;
+        }
+    } catch (error) {
+        console.error('Failed to load statistics:', error);
+    }
+}
+
+async function loadPageStatistics() {
+    try {
+        const response = await fetch('/api/v1/admin/page-stats');
+        const result = await response.json();
+
+        if (result.success) {
+            const data = result.data;
+
+            // Display page view statistics
+            displayPageStats('todayStats', data.today);
+            displayPageStats('weekStats', data.week);
+            displayPageStats('monthStats', data.month);
+            displayPageStats('totalStats', data.total);
+
+            // Display link statistics
+            if (data.linkStats) {
+                document.getElementById('totalPlayersCount').textContent = data.linkStats.total_players || 0;
+                document.getElementById('linkedPlayersCount').textContent = data.linkStats.linked_players || 0;
+                document.getElementById('linkPercentage').textContent = `${data.linkStats.link_percentage || 0}%`;
+            }
+        }
+    } catch (error) {
+        console.error('Failed to load page statistics:', error);
+        // Show error in all stat containers
+        ['todayStats', 'weekStats', 'monthStats', 'totalStats'].forEach(id => {
+            document.getElementById(id).innerHTML = '<div style="color: #dc3545;">Fehler beim Laden</div>';
+        });
+    }
+}
+
+function displayPageStats(containerId, stats) {
+    const container = document.getElementById(containerId);
+
+    if (!stats || stats.length === 0) {
+        container.innerHTML = '<div style="color: #6c757d;">0</div>';
+        return;
+    }
+
+    // Find main page visits
+    const mainPageStat = stats.find(stat => stat.page === 'main_page_visit');
+    const count = mainPageStat ? mainPageStat.count : 0;
+
+    container.innerHTML = `<div style="font-size: 1.5em; font-weight: bold; color: #00d4ff;">${count}</div>`;
+}
+
+function getPageDisplayName(page) {
+    const pageNames = {
+        'main_page_visit': '🏠 Hauptseiten-Besuche',
+        'home': '🏠 Hauptseite',
+        'login': '🔐 Login',
+        'dashboard': '📊 Dashboard',
+        'admin_login': '🛡️ Admin Login',
+        'admin_dashboard': '🛡️ Admin Dashboard',
+        'license_generator': '🔧 Lizenzgenerator',
+        'reset_password': '🔑 Passwort Reset'
+    };
+
+    return pageNames[page] || page;
+}
+
+function showUserManagement() {
+    showDataSection('users', 'Benutzer-Verwaltung');
+    loadUsers();
+}
+
+function showPlayerManagement() {
+    showDataSection('players', 'Spieler-Verwaltung');
+    loadPlayers();
+}
+
+function showRunManagement() {
+    showDataSection('runs', 'Läufe-Verwaltung');
+    loadRuns();
+}
+
+function showLocationManagement() {
+    showDataSection('locations', 'Standort-Verwaltung');
+    loadLocations();
+}
+
+function showAdminUserManagement() {
+    showDataSection('adminusers', 'Admin-Benutzer');
+    loadAdminUsers();
+}
+
+function showSystemInfo() {
+    showDataSection('system', 'System-Informationen');
+    loadSystemInfo();
+}
+
+function showDataSection(type, title) {
+    currentDataType = type;
+    document.getElementById('dataTitle').textContent = title;
+    document.getElementById('dataSection').style.display = 'block';
+    document.getElementById('searchInput').value = '';
+}
+
+async function loadUsers() {
+    // Implementation für Supabase-Benutzer
+    document.getElementById('dataContent').innerHTML = '<div class="no-data">Supabase-Benutzer werden über die Supabase-Console verwaltet</div>';
+}
+
+async function loadPlayers() {
+    try {
+        const response = await fetch('/api/v1/admin/players');
+        const result = await response.json();
+
+        if (result.success) {
+            currentData = result.data;
+            displayPlayersTable(result.data);
+        } else {
+            showError('Fehler beim Laden der Spieler');
+        }
+    } catch (error) {
+        console.error('Failed to load players:', error);
+        showError('Fehler beim Laden der Spieler');
+    }
+}
+
+async function loadRuns() {
+    try {
+        const response = await fetch('/api/v1/admin/runs');
+        const result = await response.json();
+
+        if (result.success) {
+            currentData = result.data;
+            displayRunsTable(result.data);
+        } else {
+            showError('Fehler beim Laden der Läufe');
+        }
+    } catch (error) {
+        console.error('Failed to load runs:', error);
+        showError('Fehler beim Laden der Läufe');
+    }
+}
+
+async function loadLocations() {
+    try {
+        const response = await fetch('/api/v1/admin/locations');
+        const result = await response.json();
+
+        if (result.success) {
+            currentData = result.data;
+            displayLocationsTable(result.data);
+        } else {
+            showError('Fehler beim Laden der Standorte');
+        }
+    } catch (error) {
+        console.error('Failed to load locations:', error);
+        showError('Fehler beim Laden der Standorte');
+    }
+}
+
+async function loadAdminUsers() {
+    try {
+        const response = await fetch('/api/v1/admin/adminusers');
+        const result = await response.json();
+
+        if (result.success) {
+            currentData = result.data;
+            displayAdminUsersTable(result.data);
+        } else {
+            showError('Fehler beim Laden der Admin-Benutzer');
+        }
+    } catch (error) {
+        console.error('Failed to load admin users:', error);
+        showError('Fehler beim Laden der Admin-Benutzer');
+    }
+}
+
+function displayPlayersTable(players) {
+    let html = '<div class="table-container"><table class="data-table">';
+    html += '<thead><tr><th>ID</th><th>Name</th><th>RFID UID</th><th>Supabase User</th><th>Registriert</th><th>Aktionen</th></tr></thead><tbody>';
+
+    players.forEach(player => {
+        html += `<tr>
+            <td>${player.id}</td>
+            <td>${player.full_name || '-'}</td>
+            <td>${player.rfiduid || '-'}</td>
+            <td>${player.supabase_user_id ? '✅' : '❌'}</td>
+            <td>${new Date(player.created_at).toLocaleDateString('de-DE')}</td>
+                                <td class="action-buttons">
+                        <button class="btn btn-small btn-warning" onclick="editPlayer('${player.id}')">Bearbeiten</button>
+                        <button class="btn btn-small btn-danger" onclick="deletePlayer('${player.id}')">Löschen</button>
+                    </td>
+        </tr>`;
+    });
+
+    html += '</tbody></table></div>';
+    document.getElementById('dataContent').innerHTML = html;
+}
+
+function displayRunsTable(runs) {
+    let html = '<div class="table-container"><table class="data-table">';
+    html += '<thead><tr><th>ID</th><th>Spieler</th><th>Standort</th><th>Zeit</th><th>Datum</th><th>Aktionen</th></tr></thead><tbody>';
+
+    runs.forEach(run => {
+        // Use the time_seconds value from the backend
+        const timeInSeconds = parseFloat(run.time_seconds) || 0;
+
+        html += `<tr>
+            <td>${run.id}</td>
+            <td>${run.player_name || `Player ${run.player_id}`}</td>
+            <td>${run.location_name || `Location ${run.location_id}`}</td>
+            <td>${timeInSeconds.toFixed(3)}s</td>
+            <td>${new Date(run.created_at).toLocaleDateString('de-DE')} ${new Date(run.created_at).toLocaleTimeString('de-DE')}</td>
+                                <td class="action-buttons">
+                        <button class="btn btn-small btn-warning" onclick="editRun('${run.id}')">Bearbeiten</button>
+                        <button class="btn btn-small btn-danger" onclick="deleteRun('${run.id}')">Löschen</button>
+                    </td>
+        </tr>`;
+    });
+
+    html += '</tbody></table></div>';
+    document.getElementById('dataContent').innerHTML = html;
+}
+
+function displayLocationsTable(locations) {
+    let html = '<div class="table-container"><table class="data-table">';
+    html += '<thead><tr><th>ID</th><th>Name</th><th>Latitude</th><th>Longitude</th><th>Mindestzeit (s)</th><th>Erstellt</th><th>Aktionen</th></tr></thead><tbody>';
+
+    locations.forEach(location => {
+        html += `<tr>
+            <td>${location.id}</td>
+            <td>${location.name}</td>
+            <td>${location.latitude}</td>
+            <td>${location.longitude}</td>
+            <td>${location.time_threshold ? (typeof location.time_threshold === 'object' ? location.time_threshold.seconds : location.time_threshold).toFixed(3) : '-'}</td>
+            <td>${new Date(location.created_at).toLocaleDateString('de-DE')}</td>
+                                <td class="action-buttons">
+                        <button class="btn btn-small btn-warning" onclick="editLocation('${location.id}')">Bearbeiten</button>
+                        <button class="btn btn-small btn-danger" onclick="deleteLocation('${location.id}')">Löschen</button>
+                    </td>
+        </tr>`;
+    });
+
+    html += '</tbody></table></div>';
+    document.getElementById('dataContent').innerHTML = html;
+}
+
+function displayAdminUsersTable(users) {
+    let html = '<div class="table-container"><table class="data-table">';
+    html += '<thead><tr><th>ID</th><th>Benutzername</th><th>Access Level</th><th>Aktiv</th><th>Letzter Login</th><th>Aktionen</th></tr></thead><tbody>';
+
+    users.forEach(user => {
+        const isCurrentUser = user.id === currentUser.id;
+        html += `<tr>
+            <td>${user.id}</td>
+            <td>${user.username} ${isCurrentUser ? '(Du)' : ''}</td>
+            <td>Level ${user.access_level}</td>
+            <td>${user.is_active ? '✅' : '❌'}</td>
+            <td>${user.last_login ? new Date(user.last_login).toLocaleDateString('de-DE') : 'Nie'}</td>
+            <td class="action-buttons">
+                ${!isCurrentUser ? `<button class="btn btn-small btn-danger" onclick="deleteAdminUser(${user.id})">Löschen</button>` : ''}
+            </td>
+        </tr>`;
+    });
+
+    html += '</tbody></table></div>';
+    document.getElementById('dataContent').innerHTML = html;
+}
+
+function loadSystemInfo() {
+    document.getElementById('dataContent').innerHTML = `
+        <div style="padding: 20px;">
+            <h4>Server-Informationen</h4>
+            <p><strong>Node.js Version:</strong> ${navigator.userAgent}</p>
+            <p><strong>Aktuelle Zeit:</strong> ${new Date().toLocaleString('de-DE')}</p>
+            <p><strong>Angemeldeter Benutzer:</strong> ${currentUser.username} (Level ${currentUser.access_level})</p>
+        </div>
+    `;
+}
+
+function filterData() {
+    const searchTerm = document.getElementById('searchInput').value.toLowerCase();
+    if (!currentData) return;
+
+    let filteredData = currentData.filter(item => {
+        return Object.values(item).some(value =>
+            value && value.toString().toLowerCase().includes(searchTerm)
+        );
+    });
+
+    switch (currentDataType) {
+        case 'players':
+            displayPlayersTable(filteredData);
+            break;
+        case 'runs':
+            displayRunsTable(filteredData);
+            break;
+        case 'locations':
+            displayLocationsTable(filteredData);
+            break;
+        case 'adminusers':
+            displayAdminUsersTable(filteredData);
+            break;
+        case 'achievements':
+            if (currentAchievementMode === 'achievements') {
+                currentAchievements = filteredData;
+                displayAchievements();
+            } else {
+                currentPlayers = filteredData;
+                displayPlayersWithAchievements();
+            }
+            break;
+    }
+}
+
+function refreshData() {
+    switch (currentDataType) {
+        case 'players':
+            loadPlayers();
+            break;
+        case 'runs':
+            loadRuns();
+            break;
+        case 'locations':
+            loadLocations();
+            break;
+        case 'adminusers':
+            loadAdminUsers();
+            break;
+        case 'system':
+            loadSystemInfo();
+            break;
+        case 'achievements':
+            if (currentAchievementMode === 'achievements') {
+                loadAchievements();
+            } else {
+                loadPlayersWithAchievements();
+            }
+            break;
+    }
+}
+
+function showAddModal() {
+    const modal = document.getElementById('addModal');
+    const modalTitle = document.getElementById('modalTitle');
+    const formFields = document.getElementById('formFields');
+
+    // Modal-Titel basierend auf aktuellem Datentyp setzen
+    switch (currentDataType) {
+        case 'players':
+            modalTitle.textContent = 'Neuen Spieler hinzufügen';
+            formFields.innerHTML = `
+                <div class="form-group">
+                    <label for="playerName">Vollständiger Name:</label>
+                    <input type="text" id="playerName" name="full_name" required>
+                </div>
+                <div class="form-group">
+                    <label for="playerRfid">RFID UID:</label>
+                    <input type="text" id="playerRfid" name="rfiduid" placeholder="z.B. 1234567890">
+                </div>
+                <div class="form-group">
+                    <label for="playerSupabaseId">Supabase User ID (optional):</label>
+                    <input type="text" id="playerSupabaseId" name="supabase_user_id" placeholder="UUID">
+                </div>
+            `;
+            break;
+
+        case 'locations':
+            modalTitle.textContent = 'Neuen Standort hinzufügen';
+            formFields.innerHTML = `
+                <div class="form-group">
+                    <label for="locationName">Standort-Name:</label>
+                    <input type="text" id="locationName" name="name" required>
+                </div>
+                <div class="form-group">
+                    <label for="locationLat">Breitengrad (Latitude):</label>
+                    <input type="number" id="locationLat" name="latitude" step="any" required placeholder="z.B. 48.385337">
+                </div>
+                <div class="form-group">
+                    <label for="locationLng">Längengrad (Longitude):</label>
+                    <input type="number" id="locationLng" name="longitude" step="any" required placeholder="z.B. 9.986960">
+                </div>
+                <div class="form-group">
+                    <label for="locationThreshold">Zeit-Schwellenwert (optional):</label>
+                    <input type="number" id="locationThreshold" name="time_threshold" step="0.001" placeholder="z.B. 60.000">
+                </div>
+            `;
+            break;
+
+        case 'adminusers':
+            modalTitle.textContent = 'Neuen Admin-Benutzer hinzufügen';
+            formFields.innerHTML = `
+                <div class="form-group">
+                    <label for="adminUsername">Benutzername:</label>
+                    <input type="text" id="adminUsername" name="username" required>
+                </div>
+                <div class="form-group">
+                    <label for="adminPassword">Passwort:</label>
+                    <input type="password" id="adminPassword" name="password" required minlength="6">
+                </div>
+                <div class="form-group">
+                    <label for="adminAccessLevel">Zugriffslevel:</label>
+                    <select id="adminAccessLevel" name="access_level" required>
+                        <option value="1">Level 1 - Basis-Admin</option>
+                        <option value="2">Level 2 - Vollzugriff</option>
+                    </select>
+                </div>
+            `;
+            break;
+
+        case 'runs':
+            modalTitle.textContent = 'Neuen Lauf hinzufügen';
+            formFields.innerHTML = `
+                <div class="form-group">
+                    <label for="runPlayerId">Spieler ID:</label>
+                    <input type="number" id="runPlayerId" name="player_id" required>
+                </div>
+                <div class="form-group">
+                    <label for="runLocationId">Standort ID:</label>
+                    <input type="number" id="runLocationId" name="location_id" required>
+                </div>
+                <div class="form-group">
+                    <label for="runTime">Zeit (Sekunden):</label>
+                    <input type="number" id="runTime" name="time_seconds" step="0.001" required placeholder="z.B. 60.123">
+                </div>
+            `;
+            break;
+
+        default:
+            modalTitle.textContent = 'Element hinzufügen';
+            formFields.innerHTML = '<p>Keine Felder für diesen Datentyp verfügbar.</p>';
+    }
+
+    modal.style.display = 'block';
+}
+
+function closeModal() {
+    document.querySelectorAll('.modal').forEach(modal => {
+        modal.style.display = 'none';
+    });
+    // Formular zurücksetzen
+    document.getElementById('addForm').reset();
+    document.getElementById('modalMessage').style.display = 'none';
+}
+
+async function handleAddSubmit(e) {
+    e.preventDefault();
+
+    const formData = new FormData(e.target);
+    const data = Object.fromEntries(formData.entries());
+
+    // Prüfen ob es sich um eine Edit-Operation handelt
+    const isEdit = data.edit_id;
+    const editId = data.edit_id;
+    delete data.edit_id; // edit_id aus den Daten entfernen
+
+    try {
+        let endpoint = '';
+        let successMessage = '';
+        let method = 'POST';
+
+        switch (currentDataType) {
+            case 'players':
+                endpoint = isEdit ? `/api/v1/admin/players/${editId}` : '/api/v1/admin/players';
+                successMessage = isEdit ? 'Spieler erfolgreich aktualisiert' : 'Spieler erfolgreich hinzugefügt';
+                method = isEdit ? 'PUT' : 'POST';
+                break;
+            case 'locations':
+                endpoint = isEdit ? `/api/v1/admin/locations/${editId}` : '/api/v1/admin/locations';
+                successMessage = isEdit ? 'Standort erfolgreich aktualisiert' : 'Standort erfolgreich hinzugefügt';
+                method = isEdit ? 'PUT' : 'POST';
+                break;
+            case 'adminusers':
+                endpoint = isEdit ? `/api/v1/admin/adminusers/${editId}` : '/api/v1/admin/adminusers';
+                successMessage = isEdit ? 'Admin-Benutzer erfolgreich aktualisiert' : 'Admin-Benutzer erfolgreich hinzugefügt';
+                method = isEdit ? 'PUT' : 'POST';
+                break;
+            case 'runs':
+                endpoint = isEdit ? `/api/v1/admin/runs/${editId}` : '/api/v1/admin/runs';
+                successMessage = isEdit ? 'Lauf erfolgreich aktualisiert' : 'Lauf erfolgreich hinzugefügt';
+                method = isEdit ? 'PUT' : 'POST';
+                break;
+            case 'achievements':
+                // Handle achievement form submission
+                await handleAchievementSubmit(formData);
+                return;
+            default:
+                showError('Unbekannter Datentyp');
+                return;
+        }
+
+        const response = await fetch(endpoint, {
+            method: method,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(data)
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+            showSuccess(successMessage);
+            closeModal();
+            refreshData(); // Daten neu laden
+        } else {
+            showError(result.message || `Fehler beim ${isEdit ? 'Aktualisieren' : 'Hinzufügen'}`);
+        }
+
+    } catch (error) {
+        console.error('Submit failed:', error);
+        showError(`Fehler beim ${isEdit ? 'Aktualisieren' : 'Hinzufügen'}`);
+    }
+}
+
+// Edit-Funktionen
+async function editPlayer(id) {
+    const player = currentData.find(p => p.id == id);
+    if (!player) return;
+
+    const modal = document.getElementById('addModal');
+    const modalTitle = document.getElementById('modalTitle');
+    const formFields = document.getElementById('formFields');
+
+    modalTitle.textContent = 'Spieler bearbeiten';
+    formFields.innerHTML = `
+        <div class="form-group">
+            <label for="playerName">Vollständiger Name:</label>
+            <input type="text" id="playerName" name="full_name" value="${player.full_name || ''}" required>
+        </div>
+        <div class="form-group">
+            <label for="playerRfid">RFID UID:</label>
+            <input type="text" id="playerRfid" name="rfiduid" value="${player.rfiduid || ''}" placeholder="z.B. 1234567890">
+        </div>
+        <div class="form-group">
+            <label for="playerSupabaseId">Supabase User ID (optional):</label>
+            <input type="text" id="playerSupabaseId" name="supabase_user_id" value="${player.supabase_user_id || ''}" placeholder="UUID">
+        </div>
+        <input type="hidden" name="edit_id" value="${player.id}">
+    `;
+
+    modal.style.display = 'block';
+}
+
+async function editLocation(id) {
+    const location = currentData.find(l => l.id == id);
+    if (!location) return;
+
+    const modal = document.getElementById('addModal');
+    const modalTitle = document.getElementById('modalTitle');
+    const formFields = document.getElementById('formFields');
+
+    modalTitle.textContent = 'Standort bearbeiten';
+    formFields.innerHTML = `
+        <div class="form-group">
+            <label for="locationName">Standort-Name:</label>
+            <input type="text" id="locationName" name="name" value="${location.name}" required>
+        </div>
+        <div class="form-group">
+            <label for="locationLat">Breitengrad (Latitude):</label>
+            <input type="number" id="locationLat" name="latitude" step="any" value="${location.latitude}" required placeholder="z.B. 48.385337">
+        </div>
+        <div class="form-group">
+            <label for="locationLng">Längengrad (Longitude):</label>
+            <input type="number" id="locationLng" name="longitude" step="any" value="${location.longitude}" required placeholder="z.B. 9.986960">
+        </div>
+        <div class="form-group">
+            <label for="locationThreshold">Zeit-Schwellenwert (optional):</label>
+            <input type="number" id="locationThreshold" name="time_threshold" step="0.001" value="${location.time_threshold || ''}" placeholder="z.B. 60.000">
+        </div>
+        <input type="hidden" name="edit_id" value="${location.id}">
+    `;
+
+    modal.style.display = 'block';
+}
+
+async function editRun(id) {
+    try {
+        // Lade die spezifischen Lauf-Daten direkt von der API
+        const response = await fetch(`/api/admin-runs/${id}`);
+        const result = await response.json();
+
+        if (!result.success) {
+            showError('Fehler beim Laden der Lauf-Daten: ' + (result.message || 'Unbekannter Fehler'));
+            return;
+        }
+
+        const run = result.data;
+        if (!run) {
+            showError('Lauf nicht gefunden');
+            return;
+        }
+
+        console.log('Editing run:', run); // Debug log
+
+        const modal = document.getElementById('addModal');
+        const modalTitle = document.getElementById('modalTitle');
+        const formFields = document.getElementById('formFields');
+
+        modalTitle.textContent = 'Lauf bearbeiten';
+        formFields.innerHTML = `
+            <div class="form-group">
+                <label for="runPlayerId">Spieler ID:</label>
+                <input type="text" id="runPlayerId" name="player_id" value="${run.player_id || ''}" required>
+            </div>
+            <div class="form-group">
+                <label for="runLocationId">Standort ID:</label>
+                <input type="text" id="runLocationId" name="location_id" value="${run.location_id || ''}" required>
+            </div>
+            <div class="form-group">
+                <label for="runTime">Zeit (Sekunden):</label>
+                <input type="number" id="runTime" name="time_seconds" step="0.001" value="${parseFloat(run.time_seconds || 0)}" required placeholder="z.B. 60.123">
+            </div>
+            <input type="hidden" name="edit_id" value="${run.id}">
+        `;
+
+        modal.style.display = 'block';
+
+    } catch (error) {
+        console.error('Error loading run data:', error);
+        showError('Fehler beim Laden der Lauf-Daten');
+    }
+}
+
+async function deletePlayer(id) {
+    if (await confirmDelete(`Spieler mit ID ${id} löschen?`)) {
+        try {
+            const response = await fetch(`/api/v1/admin/players/${id}`, { method: 'DELETE' });
+            const result = await response.json();
+
+            if (result.success) {
+                showSuccess('Spieler erfolgreich gelöscht');
+                loadPlayers();
+            } else {
+                showError('Fehler beim Löschen des Spielers');
+            }
+        } catch (error) {
+            console.error('Delete failed:', error);
+            showError('Fehler beim Löschen des Spielers');
+        }
+    }
+}
+
+async function deleteRun(id) {
+    if (await confirmDelete(`Lauf mit ID ${id} löschen?`)) {
+        try {
+            const response = await fetch(`/api/v1/admin/runs/${id}`, { method: 'DELETE' });
+            const result = await response.json();
+
+            if (result.success) {
+                showSuccess('Lauf erfolgreich gelöscht');
+                loadRuns();
+            } else {
+                showError('Fehler beim Löschen des Laufs');
+            }
+        } catch (error) {
+            console.error('Delete failed:', error);
+            showError('Fehler beim Löschen des Laufs');
+        }
+    }
+}
+
+async function deleteLocation(id) {
+    if (await confirmDelete(`Standort mit ID ${id} löschen?`)) {
+        try {
+            const response = await fetch(`/api/v1/admin/locations/${id}`, { method: 'DELETE' });
+            const result = await response.json();
+
+            if (result.success) {
+                showSuccess('Standort erfolgreich gelöscht');
+                loadLocations();
+            } else {
+                showError('Fehler beim Löschen des Standorts');
+            }
+        } catch (error) {
+            console.error('Delete failed:', error);
+            showError('Fehler beim Löschen des Standorts');
+        }
+    }
+}
+
+async function deleteAdminUser(id) {
+    if (await confirmDelete(`Admin-Benutzer mit ID ${id} löschen?`)) {
+        try {
+            const response = await fetch(`/api/v1/admin/adminusers/${id}`, { method: 'DELETE' });
+            const result = await response.json();
+
+            if (result.success) {
+                showSuccess('Admin-Benutzer erfolgreich gelöscht');
+                loadAdminUsers();
+            } else {
+                showError('Fehler beim Löschen des Admin-Benutzers');
+            }
+        } catch (error) {
+            console.error('Delete failed:', error);
+            showError('Fehler beim Löschen des Admin-Benutzers');
+        }
+    }
+}
+
+function confirmDelete(message) {
+    return new Promise((resolve) => {
+        document.getElementById('confirmMessage').textContent = message;
+        document.getElementById('confirmModal').style.display = 'block';
+
+        document.getElementById('confirmYes').onclick = () => {
+            closeModal();
+            resolve(true);
+        };
+
+        document.getElementById('confirmNo').onclick = () => {
+            closeModal();
+            resolve(false);
+        };
+    });
+}
+
+function showSuccess(message) {
+    const messageDiv = document.getElementById('modalMessage');
+    messageDiv.textContent = message;
+    messageDiv.className = 'message success';
+    messageDiv.style.display = 'block';
+    setTimeout(() => {
+        messageDiv.style.display = 'none';
+    }, 3000);
+}
+
+function showError(message) {
+    const messageDiv = document.getElementById('modalMessage');
+    messageDiv.textContent = message;
+    messageDiv.className = 'message error';
+    messageDiv.style.display = 'block';
+    setTimeout(() => {
+        messageDiv.style.display = 'none';
+    }, 3000);
+}
+
+// ============================================================================
+// BLACKLIST MANAGEMENT FUNCTIONS
+// ============================================================================
+
+async function showBlacklistManagement() {
+    currentDataType = 'blacklist';
+    document.getElementById('blacklistModal').style.display = 'block';
+    await loadBlacklist();
+    await loadBlacklistStats();
+}
+
+async function loadBlacklist() {
+    try {
+        const response = await fetch('/api/v1/admin/blacklist');
+        const result = await response.json();
+
+        if (result.success) {
+            displayBlacklist(result.data);
+        } else {
+            showBlacklistMessage('Fehler beim Laden der Blacklist: ' + result.message, 'error');
+        }
+    } catch (error) {
+        console.error('Error loading blacklist:', error);
+        showBlacklistMessage('Fehler beim Laden der Blacklist', 'error');
+    }
+}
+
+function displayBlacklist(blacklist) {
+    const content = document.getElementById('blacklistContent');
+
+    let html = '<h3 style="color: #ffffff; margin-bottom: 1rem;">📋 Blacklist-Inhalte</h3>';
+
+    Object.entries(blacklist).forEach(([category, terms]) => {
+        const categoryName = getCategoryDisplayName(category);
+        const categoryIcon = getCategoryIcon(category);
+
+        html += `
+            <div style="border: 1px solid #334155; padding: 1rem; margin-bottom: 1rem; border-radius: 8px; background: rgba(15, 23, 42, 0.3);">
+                <h4 style="color: #ffffff; margin-bottom: 0.75rem; display: flex; align-items: center; gap: 0.5rem;">
+                    ${categoryIcon} ${categoryName} 
+                    <span style="background: #1e293b; color: #8892b0; padding: 0.25rem 0.5rem; border-radius: 12px; font-size: 0.8rem;">
+                        ${terms.length} Einträge
+                    </span>
+                </h4>
+                <div style="display: flex; flex-wrap: wrap; gap: 0.5rem;">
+        `;
+
+        if (terms.length === 0) {
+            html += `
+                <div style="color: #64748b; font-style: italic; padding: 1rem; text-align: center; width: 100%;">
+                    Keine Einträge in dieser Kategorie
+                </div>
+            `;
+        } else {
+            terms.forEach(term => {
+                html += `
+                    <span style="background: #1e293b; color: #e2e8f0; padding: 0.375rem 0.75rem; border-radius: 6px; display: flex; align-items: center; gap: 0.5rem; border: 1px solid #334155;">
+                        <span style="font-family: monospace; font-size: 0.9rem;">${term}</span>
+                        <button onclick="removeFromBlacklist('${term}', '${category}')" 
+                                style="background: #dc2626; color: white; border: none; border-radius: 50%; width: 20px; height: 20px; cursor: pointer; font-size: 12px; display: flex; align-items: center; justify-content: center; transition: background-color 0.2s;"
+                                onmouseover="this.style.backgroundColor='#b91c1c'" 
+                                onmouseout="this.style.backgroundColor='#dc2626'"
+                                title="Entfernen">
+                            ×
+                        </button>
+                    </span>
+                `;
+            });
+        }
+
+        html += `
+                </div>
+            </div>
+        `;
+    });
+
+    content.innerHTML = html;
+}
+
+// Kategorie-Icons hinzufügen
+function getCategoryIcon(category) {
+    const icons = {
+        historical: '🏛️',
+        offensive: '⚠️',
+        titles: '👑',
+        brands: '🏷️',
+        inappropriate: '🚫',
+        racial: '🌍',
+        religious: '⛪',
+        disability: '♿',
+        leetspeak: '🔤',
+        cyberbullying: '💻',
+        drugs: '💊',
+        violence: '⚔️'
+    };
+    return icons[category] || '📝';
+}
+
+function getCategoryDisplayName(category) {
+    const names = {
+        historical: 'Historisch belastet',
+        offensive: 'Beleidigend/anstößig',
+        titles: 'Titel/Berufsbezeichnung',
+        brands: 'Markenname',
+        inappropriate: 'Unpassend',
+        racial: 'Rassistisch/ethnisch',
+        religious: 'Religiös beleidigend',
+        disability: 'Behinderungsbezogen',
+        leetspeak: 'Verschleiert',
+        cyberbullying: 'Cyberbullying',
+        drugs: 'Drogenbezogen',
+        violence: 'Gewalt/Bedrohung'
+    };
+    return names[category] || category;
+}
+
+async function testNameAgainstBlacklist() {
+    const firstname = document.getElementById('testFirstname').value.trim();
+    const lastname = document.getElementById('testLastname').value.trim();
+    const resultDiv = document.getElementById('testResult');
+
+    if (!firstname || !lastname) {
+        showBlacklistMessage('Bitte gib Vorname und Nachname ein', 'error');
+        return;
+    }
+
+    try {
+        const response = await fetch('/api/v1/admin/blacklist/test', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ firstname, lastname })
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+            const testResult = result.data;
+
+            if (testResult.isBlocked) {
+                let matchTypeText = '';
+                let similarityText = '';
+
+                if (testResult.matchType === 'exact') {
+                    matchTypeText = 'Exakte Übereinstimmung';
+                } else if (testResult.matchType === 'similar') {
+                    matchTypeText = 'Ähnliche Übereinstimmung (Levenshtein)';
+                    const similarityPercent = Math.round((1 - testResult.similarity) * 100);
+                    similarityText = `<br>Ähnlichkeit: ${similarityPercent}% (Distanz: ${testResult.levenshteinDistance})`;
+                }
+
+                resultDiv.innerHTML = `
+                    <div style="background: #ffebee; color: #c62828; padding: 0.5rem; border-radius: 3px;">
+                        <strong>❌ Name ist blockiert</strong><br>
+                        Grund: ${testResult.reason}<br>
+                        Kategorie: ${getCategoryDisplayName(testResult.category)}<br>
+                        Gefundener Begriff: "${testResult.matchedTerm}"<br>
+                        Typ: ${matchTypeText}${similarityText}
+                    </div>
+                `;
+            } else {
+                resultDiv.innerHTML = `
+                    <div style="background: #e8f5e8; color: #2e7d32; padding: 0.5rem; border-radius: 3px;">
+                        <strong>✅ Name ist erlaubt</strong><br>
+                        Der Name "${firstname} ${lastname}" ist nicht in der Blacklist.
+                    </div>
+                `;
+            }
+
+            resultDiv.style.display = 'block';
+        } else {
+            showBlacklistMessage('Fehler beim Testen: ' + result.message, 'error');
+        }
+    } catch (error) {
+        console.error('Error testing name:', error);
+        showBlacklistMessage('Fehler beim Testen des Namens', 'error');
+    }
+}
+
+// Detailed Levenshtein test function
+async function testLevenshteinDetailed() {
+    const firstname = document.getElementById('testFirstname').value.trim();
+    const lastname = document.getElementById('testLastname').value.trim();
+    const resultDiv = document.getElementById('testResult');
+
+    if (!firstname || !lastname) {
+        showBlacklistMessage('Bitte gib Vorname und Nachname ein', 'error');
+        return;
+    }
+
+    try {
+        const response = await fetch('/api/v1/admin/blacklist/levenshtein-test', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ firstname, lastname, threshold: 0.3 })
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+            const data = result.data;
+            let html = `
+                <div style="background: #f3e5f5; color: #4a148c; padding: 1rem; border-radius: 5px; margin-top: 1rem;">
+                    <h4>🔍 Detaillierte Levenshtein-Analyse</h4>
+                    <p><strong>Getesteter Name:</strong> ${data.input.firstname} ${data.input.lastname}</p>
+                    <p><strong>Schwellenwert:</strong> ${data.threshold}</p>
+                    <hr style="margin: 1rem 0;">
+            `;
+
+            // Show results for each category
+            for (const [category, categoryResult] of Object.entries(data.results)) {
+                if (categoryResult.hasSimilarTerms && categoryResult.similarTerms.length > 0) {
+                    html += `
+                        <div style="margin-bottom: 1rem; padding: 0.5rem; background: #fff3e0; border-left: 4px solid #ff9800; border-radius: 3px;">
+                            <h5>📁 ${getCategoryDisplayName(category)} (Schwellenwert: ${categoryResult.categoryThreshold})</h5>
+                    `;
+                    
+                    categoryResult.similarTerms.forEach(term => {
+                        const similarityPercent = Math.round((1 - term.distance) * 100);
+                        html += `
+                            <div style="margin: 0.5rem 0; padding: 0.5rem; background: white; border-radius: 3px;">
+                                <strong>Begriff:</strong> "${term.term}"<br>
+                                <strong>Levenshtein-Distanz:</strong> ${term.levenshteinDistance}<br>
+                                <strong>Normalisierte Distanz:</strong> ${term.distance.toFixed(4)}<br>
+                                <strong>Ähnlichkeit:</strong> ${similarityPercent}%<br>
+                                <strong>Match-Typ:</strong> ${term.matchType || 'similar'}
+                            </div>
+                        `;
+                    });
+                    
+                    html += `</div>`;
+                }
+            }
+
+            // If no matches found
+            if (!Object.values(data.results).some(r => r.hasSimilarTerms)) {
+                html += `
+                    <div style="background: #e8f5e8; color: #2e7d32; padding: 1rem; border-radius: 3px;">
+                        <strong>✅ Keine ähnlichen Begriffe gefunden</strong><br>
+                        Der Name "${data.input.firstname} ${data.input.lastname}" hat keine ähnlichen Begriffe in der Blacklist.
+                    </div>
+                `;
+            }
+
+            html += `</div>`;
+            resultDiv.innerHTML = html;
+            resultDiv.style.display = 'block';
+        } else {
+            showBlacklistMessage(result.message || 'Fehler beim Testen', 'error');
+        }
+    } catch (error) {
+        console.error('Error testing Levenshtein:', error);
+        showBlacklistMessage('Fehler beim Testen der Levenshtein-Distanz', 'error');
+    }
+}
+
+async function addToBlacklist() {
+    const term = document.getElementById('newTerm').value.trim();
+    const category = document.getElementById('newCategory').value;
+
+    if (!term) {
+        showBlacklistMessage('Bitte gib einen Begriff ein', 'error');
+        return;
+    }
+
+    try {
+        const response = await fetch('/api/v1/admin/blacklist', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ term, category })
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+            showBlacklistMessage('Begriff erfolgreich hinzugefügt', 'success');
+            document.getElementById('newTerm').value = '';
+            await loadBlacklist();
+            await loadBlacklistStats();
+        } else {
+            showBlacklistMessage('Fehler beim Hinzufügen: ' + result.message, 'error');
+        }
+    } catch (error) {
+        console.error('Error adding to blacklist:', error);
+        showBlacklistMessage('Fehler beim Hinzufügen zur Blacklist', 'error');
+    }
+}
+
+async function removeFromBlacklist(term, category) {
+    if (!confirm(`Möchtest du "${term}" aus der Kategorie "${getCategoryDisplayName(category)}" entfernen?`)) {
+        return;
+    }
+
+    try {
+        const response = await fetch('/api/v1/admin/blacklist', {
+            method: 'DELETE',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ term, category })
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+            showBlacklistMessage('Begriff erfolgreich entfernt', 'success');
+            await loadBlacklist();
+            await loadBlacklistStats();
+        } else {
+            showBlacklistMessage('Fehler beim Entfernen: ' + result.message, 'error');
+        }
+    } catch (error) {
+        console.error('Error removing from blacklist:', error);
+        showBlacklistMessage('Fehler beim Entfernen aus der Blacklist', 'error');
+    }
+}
+
+function showBlacklistMessage(message, type) {
+    const messageDiv = document.getElementById('blacklistMessage');
+    messageDiv.textContent = message;
+    messageDiv.className = `message ${type}`;
+    messageDiv.style.display = 'block';
+    setTimeout(() => {
+        messageDiv.style.display = 'none';
+    }, 3000);
+}
+
+// Blacklist-Statistiken laden
+async function loadBlacklistStats() {
+    try {
+        const response = await fetch('/api/v1/admin/blacklist/stats');
+        const result = await response.json();
+
+        if (result.success) {
+            displayBlacklistStats(result.data);
+        } else {
+            console.error('Error loading blacklist stats:', result.message);
+        }
+    } catch (error) {
+        console.error('Error loading blacklist stats:', error);
+    }
+}
+
+// Blacklist-Statistiken anzeigen
+function displayBlacklistStats(stats) {
+    // Erstelle oder aktualisiere Statistiken-Bereich
+    let statsDiv = document.getElementById('blacklistStats');
+    if (!statsDiv) {
+        // Erstelle Statistiken-Bereich am Anfang des Modals
+        const modalContent = document.querySelector('#blacklistModal .modal-content');
+        const firstChild = modalContent.firstChild;
+        statsDiv = document.createElement('div');
+        statsDiv.id = 'blacklistStats';
+        statsDiv.style.cssText = 'border: 1px solid #4ade80; padding: 1rem; margin-bottom: 1rem; border-radius: 5px; background: rgba(34, 197, 94, 0.1);';
+        modalContent.insertBefore(statsDiv, firstChild);
+    }
+
+    let html = `
+        <h4 style="color: #4ade80; margin-bottom: 1rem;">📊 Blacklist-Statistiken</h4>
+        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 1rem; margin-bottom: 1rem;">
+    `;
+
+    stats.categories.forEach(category => {
+        const categoryName = getCategoryDisplayName(category.category);
+        const lastAdded = new Date(category.last_added).toLocaleDateString('de-DE');
+        html += `
+            <div style="background: rgba(15, 23, 42, 0.5); padding: 0.75rem; border-radius: 5px; text-align: center;">
+                <div style="font-size: 1.5rem; font-weight: bold; color: #4ade80;">${category.count}</div>
+                <div style="font-size: 0.9rem; color: #8892b0;">${categoryName}</div>
+                <div style="font-size: 0.8rem; color: #64748b;">Letzte: ${lastAdded}</div>
+            </div>
+        `;
+    });
+
+    html += `
+        </div>
+        <div style="text-align: center; padding: 0.5rem; background: rgba(15, 23, 42, 0.3); border-radius: 5px;">
+            <strong style="color: #4ade80;">Gesamt: ${stats.total} Begriffe</strong>
+        </div>
+    `;
+
+    statsDiv.innerHTML = html;
+}
+
+// ==================== ACHIEVEMENT MANAGEMENT ====================
+
+let currentAchievementMode = 'achievements'; // 'achievements' or 'players'
+let currentAchievements = [];
+let currentPlayers = [];
+
+// Show achievement management
+async function showAchievementManagement() {
+    currentDataType = 'achievements';
+    currentAchievementMode = 'achievements';
+    
+    document.getElementById('dataTitle').textContent = '🏆 Achievement-Verwaltung';
+    document.getElementById('dataSection').style.display = 'block';
+    
+    // Update search placeholder
+    document.getElementById('searchInput').placeholder = 'Achievements durchsuchen...';
+    
+    await loadAchievements();
+}
+
+// Load all achievements
+async function loadAchievements() {
+    try {
+        const response = await fetch('/api/v1/admin/achievements');
+        const result = await response.json();
+        
+        if (result.success) {
+            currentAchievements = result.data;
+            currentData = result.data; // Set for filtering
+            displayAchievements();
+        } else {
+            showError('Fehler beim Laden der Achievements: ' + result.message);
+        }
+    } catch (error) {
+        console.error('Error loading achievements:', error);
+        showError('Fehler beim Laden der Achievements');
+    }
+}
+
+// Display achievements in table
+function displayAchievements() {
+    const content = document.getElementById('dataContent');
+    
+    if (currentAchievements.length === 0) {
+        content.innerHTML = '<div class="no-data">Keine Achievements gefunden</div>';
+        return;
+    }
+    
+    let html = `
+        <div class="achievement-controls">
+            <button class="btn btn-success" onclick="showAddAchievementModal()">➕ Neues Achievement</button>
+            <button class="btn" onclick="toggleAchievementMode()">👥 Spieler-Ansicht</button>
+        </div>
+        <div class="table-container">
+            <table class="data-table">
+                <thead>
+                    <tr>
+                        <th>Status</th>
+                        <th>Icon</th>
+                        <th>Name</th>
+                        <th>Kategorie</th>
+                        <th>Bedingung</th>
+                        <th>Punkte</th>
+                        <th>Mehrmals</th>
+                        <th>Aktionen</th>
+                    </tr>
+                </thead>
+                <tbody>
+    `;
+    
+    currentAchievements.forEach(achievement => {
+        const statusClass = achievement.is_active ? 'active' : 'inactive';
+        const statusText = achievement.is_active ? 'Aktiv' : 'Inaktiv';
+        const multipleText = achievement.can_be_earned_multiple_times ? 'Ja' : 'Nein';
+        
+        html += `
+            <tr>
+                <td><span class="status-badge ${statusClass}">${statusText}</span></td>
+                <td>${achievement.icon || '🏆'}</td>
+                <td>
+                    <strong>${achievement.name}</strong>
+                    ${achievement.name_en ? `<br><small>${achievement.name_en}</small>` : ''}
+                </td>
+                <td>${achievement.category}</td>
+                <td>${achievement.condition_type}: ${achievement.condition_value}</td>
+                <td>${achievement.points}</td>
+                <td>${multipleText}</td>
+                <td>
+                    <button class="btn btn-sm" onclick="editAchievement('${achievement.id}')">✏️</button>
+                    <button class="btn btn-sm btn-danger" onclick="deleteAchievement('${achievement.id}', '${achievement.name}')">🗑️</button>
+                </td>
+            </tr>
+        `;
+    });
+    
+    html += `
+                </tbody>
+            </table>
+        </div>
+    `;
+    
+    content.innerHTML = html;
+}
+
+// Handle achievement form submission
+async function handleAchievementSubmit(formData) {
+    const isEdit = formData.has('achievement_id');
+    const url = isEdit ? 
+        `/api/v1/admin/achievements/${formData.get('achievement_id')}` : 
+        '/api/v1/admin/achievements';
+    const method = isEdit ? 'PUT' : 'POST';
+    
+    const data = {
+        name: formData.get('name'),
+        name_en: formData.get('name_en') || null,
+        description: formData.get('description'),
+        description_en: formData.get('description_en') || null,
+        category: formData.get('category'),
+        condition_type: formData.get('condition_type'),
+        condition_value: parseInt(formData.get('condition_value')),
+        icon: formData.get('icon') || '🏆',
+        points: parseInt(formData.get('points')) || 10,
+        is_active: formData.has('is_active'),
+        can_be_earned_multiple_times: formData.has('can_be_earned_multiple_times')
+    };
+    
+    try {
+        const response = await fetch(url, {
+            method: method,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(data)
+        });
+        const result = await response.json();
+        
+        if (result.success) {
+            showSuccess(result.message);
+            closeModal();
+            await loadAchievements();
+        } else {
+            showError('Fehler beim Speichern: ' + result.message);
+        }
+    } catch (error) {
+        console.error('Error saving achievement:', error);
+        showError('Fehler beim Speichern des Achievements');
+    }
+}
+
+// Toggle between achievements and players view
+async function toggleAchievementMode() {
+    if (currentAchievementMode === 'achievements') {
+        currentAchievementMode = 'players';
+        document.getElementById('dataTitle').textContent = '👥 Spieler-Achievements';
+        document.getElementById('searchInput').placeholder = 'Spieler durchsuchen...';
+        await loadPlayersWithAchievements();
+    } else {
+        currentAchievementMode = 'achievements';
+        document.getElementById('dataTitle').textContent = '🏆 Achievement-Verwaltung';
+        document.getElementById('searchInput').placeholder = 'Achievements durchsuchen...';
+        await loadAchievements();
+    }
+}
+
+// Load all players with achievement statistics
+async function loadPlayersWithAchievements() {
+    try {
+        const response = await fetch('/api/v1/admin/achievements/players');
+        const result = await response.json();
+        
+        if (result.success) {
+            currentPlayers = result.data;
+            currentData = result.data; // Set for filtering
+            displayPlayersWithAchievements();
+        } else {
+            showError('Fehler beim Laden der Spieler: ' + result.message);
+        }
+    } catch (error) {
+        console.error('Error loading players:', error);
+        showError('Fehler beim Laden der Spieler');
+    }
+}
+
+// Display players in table
+function displayPlayersWithAchievements() {
+    const content = document.getElementById('dataContent');
+    
+    if (currentPlayers.length === 0) {
+        content.innerHTML = '<div class="no-data">Keine Spieler gefunden</div>';
+        return;
+    }
+    
+    let html = `
+        <div class="achievement-controls">
+            <button class="btn" onclick="toggleAchievementMode()">🏆 Achievement-Ansicht</button>
+        </div>
+        <div class="table-container">
+            <table class="data-table">
+                <thead>
+                    <tr>
+                        <th>Spieler</th>
+                        <th>Abgeschlossen</th>
+                        <th>Gesamt</th>
+                        <th>Fortschritt</th>
+                        <th>Punkte</th>
+                        <th>Aktionen</th>
+                    </tr>
+                </thead>
+                <tbody>
+    `;
+    
+    currentPlayers.forEach(player => {
+        const progressPercentage = player.completion_percentage || 0;
+        const progressBar = `
+            <div class="progress-bar">
+                <div class="progress-fill" style="width: ${progressPercentage}%"></div>
+                <span class="progress-text">${progressPercentage}%</span>
+            </div>
+        `;
+        
+        html += `
+            <tr>
+                <td><strong>${player.firstname} ${player.lastname}</strong></td>
+                <td>${player.completed_achievements}</td>
+                <td>${player.total_achievements}</td>
+                <td>${progressBar}</td>
+                <td>${player.total_points}</td>
+                <td>
+                    <button class="btn btn-sm" onclick="viewPlayerAchievements('${player.id}', '${player.firstname} ${player.lastname}')">👁️</button>
+                </td>
+            </tr>
+        `;
+    });
+    
+    html += `
+                </tbody>
+            </table>
+        </div>
+    `;
+    
+    content.innerHTML = html;
+}
+
+// Show add achievement modal
+function showAddAchievementModal() {
+    const modal = document.getElementById('addModal');
+    const modalTitle = document.getElementById('modalTitle');
+    const formFields = document.getElementById('formFields');
+    
+    modalTitle.textContent = 'Neues Achievement erstellen';
+    
+    formFields.innerHTML = `
+        <div class="form-group">
+            <label for="achievement_name">Name *</label>
+            <input type="text" id="achievement_name" name="name" required>
+        </div>
+        <div class="form-group">
+            <label for="achievement_name_en">Name (Englisch)</label>
+            <input type="text" id="achievement_name_en" name="name_en">
+        </div>
+        <div class="form-group">
+            <label for="achievement_description">Beschreibung *</label>
+            <textarea id="achievement_description" name="description" required></textarea>
+        </div>
+        <div class="form-group">
+            <label for="achievement_description_en">Beschreibung (Englisch)</label>
+            <textarea id="achievement_description_en" name="description_en"></textarea>
+        </div>
+        <div class="form-group">
+            <label for="achievement_category">Kategorie *</label>
+            <select id="achievement_category" name="category" required>
+                <option value="">Kategorie wählen</option>
+                <option value="consistency">Konsistenz</option>
+                <option value="improvement">Verbesserung</option>
+                <option value="seasonal">Saisonal</option>
+                <option value="monthly">Monatlich</option>
+                <option value="best_time">Beste Zeit</option>
+            </select>
+        </div>
+        <div class="form-group">
+            <label for="achievement_condition_type">Bedingungstyp *</label>
+            <input type="text" id="achievement_condition_type" name="condition_type" required placeholder="z.B. first_time, attempts_per_day">
+        </div>
+        <div class="form-group">
+            <label for="achievement_condition_value">Bedingungswert *</label>
+            <input type="number" id="achievement_condition_value" name="condition_value" required>
+        </div>
+        <div class="form-group">
+            <label for="achievement_icon">Icon</label>
+            <input type="text" id="achievement_icon" name="icon" value="🏆">
+        </div>
+        <div class="form-group">
+            <label for="achievement_points">Punkte</label>
+            <input type="number" id="achievement_points" name="points" value="10">
+        </div>
+        <div class="form-group">
+            <label>
+                <input type="checkbox" id="achievement_is_active" name="is_active" checked>
+                Aktiv
+            </label>
+        </div>
+        <div class="form-group">
+            <label>
+                <input type="checkbox" id="achievement_multiple" name="can_be_earned_multiple_times">
+                Kann mehrmals erreicht werden
+            </label>
+        </div>
+    `;
+    
+    modal.style.display = 'block';
+}
+
+// Edit achievement
+async function editAchievement(achievementId) {
+    const achievement = currentAchievements.find(a => a.id === achievementId);
+    if (!achievement) return;
+    
+    const modal = document.getElementById('addModal');
+    const modalTitle = document.getElementById('modalTitle');
+    const formFields = document.getElementById('formFields');
+    
+    modalTitle.textContent = 'Achievement bearbeiten';
+    
+    formFields.innerHTML = `
+        <input type="hidden" id="achievement_id" value="${achievement.id}">
+        <div class="form-group">
+            <label for="achievement_name">Name *</label>
+            <input type="text" id="achievement_name" name="name" value="${achievement.name}" required>
+        </div>
+        <div class="form-group">
+            <label for="achievement_name_en">Name (Englisch)</label>
+            <input type="text" id="achievement_name_en" name="name_en" value="${achievement.name_en || ''}">
+        </div>
+        <div class="form-group">
+            <label for="achievement_description">Beschreibung *</label>
+            <textarea id="achievement_description" name="description" required>${achievement.description}</textarea>
+        </div>
+        <div class="form-group">
+            <label for="achievement_description_en">Beschreibung (Englisch)</label>
+            <textarea id="achievement_description_en" name="description_en">${achievement.description_en || ''}</textarea>
+        </div>
+        <div class="form-group">
+            <label for="achievement_category">Kategorie *</label>
+            <select id="achievement_category" name="category" required>
+                <option value="consistency" ${achievement.category === 'consistency' ? 'selected' : ''}>Konsistenz</option>
+                <option value="improvement" ${achievement.category === 'improvement' ? 'selected' : ''}>Verbesserung</option>
+                <option value="seasonal" ${achievement.category === 'seasonal' ? 'selected' : ''}>Saisonal</option>
+                <option value="monthly" ${achievement.category === 'monthly' ? 'selected' : ''}>Monatlich</option>
+                <option value="best_time" ${achievement.category === 'best_time' ? 'selected' : ''}>Beste Zeit</option>
+            </select>
+        </div>
+        <div class="form-group">
+            <label for="achievement_condition_type">Bedingungstyp *</label>
+            <input type="text" id="achievement_condition_type" name="condition_type" value="${achievement.condition_type}" required>
+        </div>
+        <div class="form-group">
+            <label for="achievement_condition_value">Bedingungswert *</label>
+            <input type="number" id="achievement_condition_value" name="condition_value" value="${achievement.condition_value}" required>
+        </div>
+        <div class="form-group">
+            <label for="achievement_icon">Icon</label>
+            <input type="text" id="achievement_icon" name="icon" value="${achievement.icon || '🏆'}">
+        </div>
+        <div class="form-group">
+            <label for="achievement_points">Punkte</label>
+            <input type="number" id="achievement_points" name="points" value="${achievement.points}">
+        </div>
+        <div class="form-group">
+            <label>
+                <input type="checkbox" id="achievement_is_active" name="is_active" ${achievement.is_active ? 'checked' : ''}>
+                Aktiv
+            </label>
+        </div>
+        <div class="form-group">
+            <label>
+                <input type="checkbox" id="achievement_multiple" name="can_be_earned_multiple_times" ${achievement.can_be_earned_multiple_times ? 'checked' : ''}>
+                Kann mehrmals erreicht werden
+            </label>
+        </div>
+    `;
+    
+    modal.style.display = 'block';
+}
+
+// Delete achievement
+function deleteAchievement(achievementId, achievementName) {
+    document.getElementById('confirmMessage').textContent = `Möchten Sie das Achievement "${achievementName}" wirklich deaktivieren?`;
+    document.getElementById('confirmYes').onclick = () => confirmDeleteAchievement(achievementId);
+    document.getElementById('confirmModal').style.display = 'block';
+}
+
+// Confirm delete achievement
+async function confirmDeleteAchievement(achievementId) {
+    try {
+        const response = await fetch(`/api/v1/admin/achievements/${achievementId}`, {
+            method: 'DELETE'
+        });
+        const result = await response.json();
+        
+        if (result.success) {
+            showSuccess(result.message);
+            closeModal();
+            await loadAchievements();
+        } else {
+            showError('Fehler beim Löschen: ' + result.message);
+        }
+    } catch (error) {
+        console.error('Error deleting achievement:', error);
+        showError('Fehler beim Löschen des Achievements');
+    }
+}
+
+// View player achievements
+async function viewPlayerAchievements(playerId, playerName) {
+    try {
+        const response = await fetch(`/api/v1/admin/achievements/players/${playerId}`);
+        const result = await response.json();
+        
+        if (result.success) {
+            showPlayerAchievementsModal(result.player, result.data);
+        } else {
+            showError('Fehler beim Laden der Spieler-Achievements: ' + result.message);
+        }
+    } catch (error) {
+        console.error('Error loading player achievements:', error);
+        showError('Fehler beim Laden der Spieler-Achievements');
+    }
+}
+
+// Show player achievements modal
+function showPlayerAchievementsModal(player, achievements) {
+    const modal = document.getElementById('addModal');
+    const modalTitle = document.getElementById('modalTitle');
+    const formFields = document.getElementById('formFields');
+    
+    modalTitle.textContent = `Achievements von ${player.firstname} ${player.lastname}`;
+    
+    let html = `
+        <div class="player-achievements">
+            <div class="achievement-stats">
+                <div class="stat-item">
+                    <strong>Abgeschlossen:</strong> ${achievements.filter(a => a.is_completed).length} / ${achievements.length}
+                </div>
+                <div class="stat-item">
+                    <strong>Gesamtpunkte:</strong> ${achievements.filter(a => a.is_completed).reduce((sum, a) => sum + a.points, 0)}
+                </div>
+            </div>
+            <div class="achievements-list">
+    `;
+    
+    achievements.forEach(achievement => {
+        const statusClass = achievement.is_completed ? 'completed' : 'not-completed';
+        const statusIcon = achievement.is_completed ? '✅' : '❌';
+        const completionCount = achievement.completion_count || 0;
+        
+        html += `
+            <div class="achievement-item ${statusClass}">
+                <div class="achievement-header">
+                    <span class="achievement-icon">${achievement.icon}</span>
+                    <span class="achievement-name">${achievement.name}</span>
+                    <span class="achievement-status">${statusIcon}</span>
+                </div>
+                <div class="achievement-details">
+                    <p>${achievement.description}</p>
+                    <div class="achievement-meta">
+                        <span>Kategorie: ${achievement.category}</span>
+                        <span>Punkte: ${achievement.points}</span>
+                        ${achievement.is_completed ? `<span>Erreicht: ${new Date(achievement.earned_at).toLocaleDateString('de-DE')}</span>` : ''}
+                        ${completionCount > 1 ? `<span>Anzahl: ${completionCount}</span>` : ''}
+                    </div>
+                    <div class="achievement-actions">
+                        ${!achievement.is_completed ? 
+                            `<button class="btn btn-sm btn-success" onclick="awardAchievement('${player.id}', '${achievement.id}', '${achievement.name}')">Vergeben</button>` :
+                            `<button class="btn btn-sm btn-danger" onclick="revokeAchievement('${player.id}', '${achievement.id}', '${achievement.name}')">Entfernen</button>`
+                        }
+                    </div>
+                </div>
+            </div>
+        `;
+    });
+    
+    html += `
+            </div>
+        </div>
+    `;
+    
+    formFields.innerHTML = html;
+    modal.style.display = 'block';
+}
+
+// Award achievement to player
+async function awardAchievement(playerId, achievementId, achievementName) {
+    try {
+        const response = await fetch(`/api/v1/admin/achievements/players/${playerId}/award`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                achievement_id: achievementId,
+                progress: 1
+            })
+        });
+        const result = await response.json();
+        
+        if (result.success) {
+            showSuccess(result.message);
+            // Refresh player achievements
+            await viewPlayerAchievements(playerId, '');
+        } else {
+            showError('Fehler beim Vergeben: ' + result.message);
+        }
+    } catch (error) {
+        console.error('Error awarding achievement:', error);
+        showError('Fehler beim Vergeben des Achievements');
+    }
+}
+
+// Revoke achievement from player
+async function revokeAchievement(playerId, achievementId, achievementName) {
+    if (!confirm(`Möchten Sie das Achievement "${achievementName}" wirklich entfernen?`)) {
+        return;
+    }
+    
+    try {
+        const response = await fetch(`/api/v1/admin/achievements/players/${playerId}/revoke`, {
+            method: 'DELETE',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                achievement_id: achievementId
+            })
+        });
+        const result = await response.json();
+        
+        if (result.success) {
+            showSuccess(result.message);
+            // Refresh player achievements
+            await viewPlayerAchievements(playerId, '');
+        } else {
+            showError('Fehler beim Entfernen: ' + result.message);
+        }
+    } catch (error) {
+        console.error('Error revoking achievement:', error);
+        showError('Fehler beim Entfernen des Achievements');
+    }
+}
+
diff --git a/public/js/adminlogin.js b/public/js/adminlogin.js
new file mode 100644
index 0000000..cbdbe31
--- /dev/null
+++ b/public/js/adminlogin.js
@@ -0,0 +1,91 @@
+function showMessage(elementId, message, isError = false) {
+    const messageDiv = document.getElementById(elementId);
+    messageDiv.textContent = message;
+    messageDiv.classList.add("show");
+    setTimeout(() => {
+        messageDiv.classList.remove("show");
+    }, 4000);
+}
+
+function showError(message) {
+    showMessage("error", message, true);
+}
+
+function showSuccess(message) {
+    showMessage("success", message, false);
+}
+
+function setLoading(isLoading) {
+    const btnText = document.getElementById("btn-text");
+    const btn = document.getElementById("loginBtn");
+    
+    if (isLoading) {
+        btnText.innerHTML = '<span class="loading"></span>Anmelde...';
+        btn.disabled = true;
+    } else {
+        btnText.textContent = 'Anmelden';
+        btn.disabled = false;
+    }
+}
+
+async function handleLogin(event) {
+    event.preventDefault();
+    
+    const username = document.getElementById('username').value.trim();
+    const password = document.getElementById('password').value;
+    
+    if (!username || !password) {
+        showError('Bitte füllen Sie alle Felder aus.');
+        return;
+    }
+
+    setLoading(true);
+    
+    try {
+        const response = await fetch('/api/v1/public/login', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ username, password })
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+            showSuccess('✅ Anmeldung erfolgreich! Weiterleitung...');
+            setTimeout(() => {
+                window.location.href = '/admin-dashboard';
+            }, 1000);
+        } else {
+            showError(result.message || 'Anmeldung fehlgeschlagen');
+        }
+    } catch (error) {
+        console.error('Fehler bei der Anmeldung:', error);
+        showError('Verbindungsfehler. Bitte versuchen Sie es erneut.');
+    } finally {
+        setLoading(false);
+    }
+}
+
+// Enter-Taste für Login
+document.addEventListener('keypress', function(e) {
+    if (e.key === 'Enter') {
+        handleLogin(e);
+    }
+});
+
+// Fokus auf erstes Eingabefeld
+document.addEventListener('DOMContentLoaded', function() {
+    document.getElementById('username').focus();
+    
+    // Add cookie settings button functionality
+    const cookieSettingsBtn = document.getElementById('cookie-settings-footer');
+    if (cookieSettingsBtn) {
+        cookieSettingsBtn.addEventListener('click', function() {
+            if (window.cookieConsent) {
+                window.cookieConsent.resetConsent();
+            }
+        });
+    }
+});
diff --git a/public/js/cookie-consent.js b/public/js/cookie-consent.js
new file mode 100644
index 0000000..1e23323
--- /dev/null
+++ b/public/js/cookie-consent.js
@@ -0,0 +1,601 @@
+// Cookie Consent Management
+class CookieConsent {
+    constructor() {
+        this.cookieName = 'ninjacross_cookie_consent';
+        this.cookieSettingsName = 'ninjacross_cookie_settings';
+        this.consentGiven = false;
+        this.settings = {
+            necessary: true, // Always true, can't be disabled
+            functional: false,
+            analytics: false
+        };
+        
+        this.init();
+    }
+
+    init() {
+        // Check if consent was already given
+        const savedConsent = this.getCookie(this.cookieName);
+        const savedSettings = this.getCookie(this.cookieSettingsName);
+        
+        if (savedConsent === 'true') {
+            this.consentGiven = true;
+            if (savedSettings) {
+                this.settings = { ...this.settings, ...JSON.parse(savedSettings) };
+            }
+            this.applySettings();
+        } else {
+            this.showConsentBanner();
+        }
+    }
+
+    showConsentBanner() {
+        // Don't show banner if already shown
+        if (document.getElementById('cookie-consent-banner')) {
+            return;
+        }
+
+        const banner = document.createElement('div');
+        banner.id = 'cookie-consent-banner';
+        banner.innerHTML = `
+            <div class="cookie-banner">
+                <div class="cookie-content">
+                    <div class="cookie-icon">🍪</div>
+                    <div class="cookie-text">
+                        <h3>Cookie-Einstellungen</h3>
+                        <p>Wir verwenden Cookies, um Ihnen die beste Erfahrung auf unserer Website zu bieten. Einige sind notwendig, andere helfen uns, die Website zu verbessern.</p>
+                    </div>
+                </div>
+                <div class="cookie-actions">
+                    <button id="cookie-settings-btn" class="btn-cookie-settings">Einstellungen</button>
+                    <button id="cookie-accept-all" class="btn-cookie-accept">Alle akzeptieren</button>
+                    <button id="cookie-accept-necessary" class="btn-cookie-necessary">Nur notwendige</button>
+                </div>
+            </div>
+        `;
+
+        // Add styles
+        const style = document.createElement('style');
+        style.textContent = `
+            #cookie-consent-banner {
+                position: fixed;
+                bottom: 0;
+                left: 0;
+                right: 0;
+                background: linear-gradient(135deg, #1e3c72 0%, #2a5298 100%);
+                color: white;
+                z-index: 10000;
+                box-shadow: 0 -4px 20px rgba(0,0,0,0.3);
+                animation: slideUp 0.3s ease-out;
+            }
+
+            @keyframes slideUp {
+                from { transform: translateY(100%); }
+                to { transform: translateY(0); }
+            }
+
+            .cookie-banner {
+                display: flex;
+                align-items: center;
+                justify-content: space-between;
+                padding: 20px;
+                max-width: 1200px;
+                margin: 0 auto;
+                gap: 20px;
+            }
+
+            .cookie-content {
+                display: flex;
+                align-items: center;
+                gap: 15px;
+                flex: 1;
+            }
+
+            .cookie-icon {
+                font-size: 2rem;
+                flex-shrink: 0;
+            }
+
+            .cookie-text h3 {
+                margin: 0 0 5px 0;
+                font-size: 1.1rem;
+                color: white;
+            }
+
+            .cookie-text p {
+                margin: 0;
+                font-size: 0.9rem;
+                opacity: 0.9;
+                line-height: 1.4;
+            }
+
+            .cookie-actions {
+                display: flex;
+                gap: 10px;
+                flex-shrink: 0;
+            }
+
+            .btn-cookie-settings,
+            .btn-cookie-accept,
+            .btn-cookie-necessary {
+                padding: 10px 16px;
+                border: none;
+                border-radius: 6px;
+                cursor: pointer;
+                font-size: 0.9rem;
+                font-weight: 500;
+                transition: all 0.2s ease;
+            }
+
+            .btn-cookie-settings {
+                background: rgba(255,255,255,0.2);
+                color: white;
+                border: 1px solid rgba(255,255,255,0.3);
+            }
+
+            .btn-cookie-settings:hover {
+                background: rgba(255,255,255,0.3);
+            }
+
+            .btn-cookie-accept {
+                background: #10b981;
+                color: white;
+            }
+
+            .btn-cookie-accept:hover {
+                background: #059669;
+            }
+
+            .btn-cookie-necessary {
+                background: #6b7280;
+                color: white;
+            }
+
+            .btn-cookie-necessary:hover {
+                background: #4b5563;
+            }
+
+            @media (max-width: 768px) {
+                .cookie-banner {
+                    flex-direction: column;
+                    text-align: center;
+                    gap: 15px;
+                }
+
+                .cookie-content {
+                    flex-direction: column;
+                    text-align: center;
+                }
+
+                .cookie-actions {
+                    flex-wrap: wrap;
+                    justify-content: center;
+                }
+            }
+        `;
+
+        document.head.appendChild(style);
+        document.body.appendChild(banner);
+
+        // Add event listeners
+        document.getElementById('cookie-accept-all').addEventListener('click', () => {
+            this.acceptAll();
+        });
+
+        document.getElementById('cookie-accept-necessary').addEventListener('click', () => {
+            this.acceptNecessary();
+        });
+
+        document.getElementById('cookie-settings-btn').addEventListener('click', () => {
+            this.showSettingsModal();
+        });
+    }
+
+    showSettingsModal() {
+        // Remove banner
+        const banner = document.getElementById('cookie-consent-banner');
+        if (banner) {
+            banner.remove();
+        }
+
+        // Create modal
+        const modal = document.createElement('div');
+        modal.id = 'cookie-settings-modal';
+        modal.innerHTML = `
+            <div class="cookie-modal-overlay">
+                <div class="cookie-modal">
+                    <div class="cookie-modal-header">
+                        <h2>🍪 Cookie-Einstellungen</h2>
+                        <button id="cookie-modal-close" class="btn-close">&times;</button>
+                    </div>
+                    <div class="cookie-modal-content">
+                        <p>Wählen Sie aus, welche Cookies Sie zulassen möchten:</p>
+                        
+                        <div class="cookie-category">
+                            <div class="cookie-category-header">
+                                <h3>Notwendige Cookies</h3>
+                                <label class="cookie-toggle">
+                                    <input type="checkbox" id="necessary-cookies" checked disabled>
+                                    <span class="toggle-slider"></span>
+                                </label>
+                            </div>
+                            <p>Diese Cookies sind für die Grundfunktionen der Website erforderlich und können nicht deaktiviert werden.</p>
+                        </div>
+
+                        <div class="cookie-category">
+                            <div class="cookie-category-header">
+                                <h3>Funktionale Cookies</h3>
+                                <label class="cookie-toggle">
+                                    <input type="checkbox" id="functional-cookies" ${this.settings.functional ? 'checked' : ''}>
+                                    <span class="toggle-slider"></span>
+                                </label>
+                            </div>
+                            <p>Diese Cookies ermöglichen erweiterte Funktionen wie Benutzeranmeldung und Einstellungen.</p>
+                        </div>
+
+                        <div class="cookie-category">
+                            <div class="cookie-category-header">
+                                <h3>Analyse-Cookies</h3>
+                                <label class="cookie-toggle">
+                                    <input type="checkbox" id="analytics-cookies" ${this.settings.analytics ? 'checked' : ''}>
+                                    <span class="toggle-slider"></span>
+                                </label>
+                            </div>
+                            <p>Diese Cookies helfen uns zu verstehen, wie Besucher mit der Website interagieren.</p>
+                        </div>
+                    </div>
+                    <div class="cookie-modal-footer">
+                        <button id="cookie-save-settings" class="btn-save">Einstellungen speichern</button>
+                        <button id="cookie-accept-all-modal" class="btn-accept-all">Alle akzeptieren</button>
+                    </div>
+                </div>
+            </div>
+        `;
+
+        // Add modal styles
+        const modalStyle = document.createElement('style');
+        modalStyle.textContent = `
+            .cookie-modal-overlay {
+                position: fixed;
+                top: 0;
+                left: 0;
+                right: 0;
+                bottom: 0;
+                background: rgba(0,0,0,0.5);
+                z-index: 10001;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                padding: 20px;
+            }
+
+            .cookie-modal {
+                background: white;
+                border-radius: 12px;
+                max-width: 600px;
+                width: 100%;
+                max-height: 80vh;
+                overflow-y: auto;
+                box-shadow: 0 20px 40px rgba(0,0,0,0.3);
+                animation: modalSlideIn 0.3s ease-out;
+            }
+
+            @keyframes modalSlideIn {
+                from { transform: scale(0.9); opacity: 0; }
+                to { transform: scale(1); opacity: 1; }
+            }
+
+            .cookie-modal-header {
+                display: flex;
+                justify-content: space-between;
+                align-items: center;
+                padding: 20px;
+                border-bottom: 1px solid #e2e8f0;
+            }
+
+            .cookie-modal-header h2 {
+                margin: 0;
+                color: #1e3c72;
+            }
+
+            .btn-close {
+                background: none;
+                border: none;
+                font-size: 1.5rem;
+                cursor: pointer;
+                color: #6b7280;
+                padding: 0;
+                width: 30px;
+                height: 30px;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+            }
+
+            .btn-close:hover {
+                color: #374151;
+            }
+
+            .cookie-modal-content {
+                padding: 20px;
+            }
+
+            .cookie-category {
+                margin-bottom: 20px;
+                padding: 15px;
+                border: 1px solid #e2e8f0;
+                border-radius: 8px;
+            }
+
+            .cookie-category-header {
+                display: flex;
+                justify-content: space-between;
+                align-items: center;
+                margin-bottom: 10px;
+            }
+
+            .cookie-category-header h3 {
+                margin: 0;
+                color: #1e3c72;
+                font-size: 1.1rem;
+            }
+
+            .cookie-category p {
+                margin: 0;
+                color: #6b7280;
+                font-size: 0.9rem;
+                line-height: 1.4;
+            }
+
+            .cookie-toggle {
+                position: relative;
+                display: inline-block;
+                width: 50px;
+                height: 24px;
+            }
+
+            .cookie-toggle input {
+                opacity: 0;
+                width: 0;
+                height: 0;
+            }
+
+            .toggle-slider {
+                position: absolute;
+                cursor: pointer;
+                top: 0;
+                left: 0;
+                right: 0;
+                bottom: 0;
+                background-color: #ccc;
+                transition: .4s;
+                border-radius: 24px;
+            }
+
+            .toggle-slider:before {
+                position: absolute;
+                content: "";
+                height: 18px;
+                width: 18px;
+                left: 3px;
+                bottom: 3px;
+                background-color: white;
+                transition: .4s;
+                border-radius: 50%;
+            }
+
+            .cookie-toggle input:checked + .toggle-slider {
+                background-color: #1e3c72;
+            }
+
+            .cookie-toggle input:checked + .toggle-slider:before {
+                transform: translateX(26px);
+            }
+
+            .cookie-toggle input:disabled + .toggle-slider {
+                background-color: #10b981;
+                cursor: not-allowed;
+            }
+
+            .cookie-modal-footer {
+                padding: 20px;
+                border-top: 1px solid #e2e8f0;
+                display: flex;
+                gap: 10px;
+                justify-content: flex-end;
+            }
+
+            .btn-save, .btn-accept-all {
+                padding: 10px 20px;
+                border: none;
+                border-radius: 6px;
+                cursor: pointer;
+                font-weight: 500;
+                transition: all 0.2s ease;
+            }
+
+            .btn-save {
+                background: #1e3c72;
+                color: white;
+            }
+
+            .btn-save:hover {
+                background: #2a5298;
+            }
+
+            .btn-accept-all {
+                background: #10b981;
+                color: white;
+            }
+
+            .btn-accept-all:hover {
+                background: #059669;
+            }
+
+            @media (max-width: 768px) {
+                .cookie-modal {
+                    margin: 10px;
+                    max-height: 90vh;
+                }
+
+                .cookie-modal-footer {
+                    flex-direction: column;
+                }
+
+                .btn-save, .btn-accept-all {
+                    width: 100%;
+                }
+            }
+        `;
+
+        document.head.appendChild(modalStyle);
+        document.body.appendChild(modal);
+
+        // Add event listeners
+        document.getElementById('cookie-modal-close').addEventListener('click', () => {
+            modal.remove();
+            this.showConsentBanner();
+        });
+
+        document.getElementById('cookie-save-settings').addEventListener('click', () => {
+            this.saveSettings();
+            modal.remove();
+        });
+
+        document.getElementById('cookie-accept-all-modal').addEventListener('click', () => {
+            this.acceptAll();
+            modal.remove();
+        });
+
+        // Close on overlay click
+        modal.querySelector('.cookie-modal-overlay').addEventListener('click', (e) => {
+            if (e.target === e.currentTarget) {
+                modal.remove();
+                this.showConsentBanner();
+            }
+        });
+    }
+
+    saveSettings() {
+        this.settings.functional = document.getElementById('functional-cookies').checked;
+        this.settings.analytics = document.getElementById('analytics-cookies').checked;
+        
+        this.setCookie(this.cookieName, 'true', 365);
+        this.setCookie(this.cookieSettingsName, JSON.stringify(this.settings), 365);
+        
+        this.consentGiven = true;
+        this.applySettings();
+    }
+
+    acceptAll() {
+        this.settings.functional = true;
+        this.settings.analytics = true;
+        
+        this.setCookie(this.cookieName, 'true', 365);
+        this.setCookie(this.cookieSettingsName, JSON.stringify(this.settings), 365);
+        
+        this.consentGiven = true;
+        this.applySettings();
+    }
+
+    acceptNecessary() {
+        this.settings.functional = false;
+        this.settings.analytics = false;
+        
+        this.setCookie(this.cookieName, 'true', 365);
+        this.setCookie(this.cookieSettingsName, JSON.stringify(this.settings), 365);
+        
+        this.consentGiven = true;
+        this.applySettings();
+    }
+
+    applySettings() {
+        // Remove banner if exists
+        const banner = document.getElementById('cookie-consent-banner');
+        if (banner) {
+            banner.remove();
+        }
+
+        // Apply functional cookies
+        if (this.settings.functional) {
+            // Enable functional features
+            console.log('Functional cookies enabled');
+        } else {
+            // Disable functional features
+            console.log('Functional cookies disabled');
+        }
+
+        // Apply analytics cookies
+        if (this.settings.analytics) {
+            // Enable analytics
+            console.log('Analytics cookies enabled');
+            this.enableAnalytics();
+        } else {
+            // Disable analytics
+            console.log('Analytics cookies disabled');
+            this.disableAnalytics();
+        }
+    }
+
+    enableAnalytics() {
+        // Enable page tracking
+        if (typeof trackPageView === 'function') {
+            trackPageView('main_page_visit');
+        }
+    }
+
+    disableAnalytics() {
+        // Disable page tracking
+        console.log('Analytics disabled by user choice');
+    }
+
+    setCookie(name, value, days) {
+        const expires = new Date();
+        expires.setTime(expires.getTime() + (days * 24 * 60 * 60 * 1000));
+        document.cookie = `${name}=${value};expires=${expires.toUTCString()};path=/;SameSite=Lax`;
+    }
+
+    getCookie(name) {
+        const nameEQ = name + "=";
+        const ca = document.cookie.split(';');
+        for (let i = 0; i < ca.length; i++) {
+            let c = ca[i];
+            while (c.charAt(0) === ' ') c = c.substring(1, c.length);
+            if (c.indexOf(nameEQ) === 0) return c.substring(nameEQ.length, c.length);
+        }
+        return null;
+    }
+
+    // Public method to check if consent was given
+    hasConsent() {
+        return this.consentGiven;
+    }
+
+    // Public method to get current settings
+    getSettings() {
+        return { ...this.settings };
+    }
+
+    // Public method to reset consent
+    resetConsent() {
+        this.setCookie(this.cookieName, '', -1);
+        this.setCookie(this.cookieSettingsName, '', -1);
+        this.consentGiven = false;
+        this.settings = {
+            necessary: true,
+            functional: false,
+            analytics: false
+        };
+        this.showConsentBanner();
+    }
+}
+
+// Initialize cookie consent when DOM is loaded
+document.addEventListener('DOMContentLoaded', function() {
+    window.cookieConsent = new CookieConsent();
+});
+
+// Export for use in other scripts
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = CookieConsent;
+}
diff --git a/public/js/cookie-utils.js b/public/js/cookie-utils.js
new file mode 100644
index 0000000..1264cf2
--- /dev/null
+++ b/public/js/cookie-utils.js
@@ -0,0 +1,105 @@
+// Cookie Utility Functions
+class CookieManager {
+    // Set a cookie
+    static setCookie(name, value, days = 30) {
+        const expires = new Date();
+        expires.setTime(expires.getTime() + (days * 24 * 60 * 60 * 1000));
+        document.cookie = `${name}=${value};expires=${expires.toUTCString()};path=/;SameSite=Lax`;
+    }
+
+    // Get a cookie
+    static getCookie(name) {
+        const nameEQ = name + "=";
+        const ca = document.cookie.split(';');
+        for (let i = 0; i < ca.length; i++) {
+            let c = ca[i];
+            while (c.charAt(0) === ' ') c = c.substring(1, c.length);
+            if (c.indexOf(nameEQ) === 0) return c.substring(nameEQ.length, c.length);
+        }
+        return null;
+    }
+
+    // Delete a cookie
+    static deleteCookie(name) {
+        document.cookie = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 UTC;path=/;`;
+    }
+
+    // Check if cookies are enabled
+    static areCookiesEnabled() {
+        try {
+            this.setCookie('test', 'test');
+            const enabled = this.getCookie('test') === 'test';
+            this.deleteCookie('test');
+            return enabled;
+        } catch (e) {
+            return false;
+        }
+    }
+}
+
+// Location-specific cookie functions
+class LocationCookieManager {
+    static COOKIE_NAME = 'ninjacross_last_location';
+    static COOKIE_EXPIRY_DAYS = 90; // 3 months
+
+    // Save last selected location
+    static saveLastLocation(locationId, locationName) {
+        if (!locationId || !locationName) return;
+        
+        const locationData = {
+            id: locationId,
+            name: locationName,
+            timestamp: new Date().toISOString()
+        };
+        
+        try {
+            CookieManager.setCookie(
+                this.COOKIE_NAME, 
+                JSON.stringify(locationData), 
+                this.COOKIE_EXPIRY_DAYS
+            );
+            console.log('✅ Location saved to cookie:', locationName);
+        } catch (error) {
+            console.error('❌ Failed to save location to cookie:', error);
+        }
+    }
+
+    // Get last selected location
+    static getLastLocation() {
+        try {
+            const cookieValue = CookieManager.getCookie(this.COOKIE_NAME);
+            if (!cookieValue) return null;
+            
+            const locationData = JSON.parse(cookieValue);
+            
+            // Check if cookie is not too old (optional: 30 days max)
+            const cookieDate = new Date(locationData.timestamp);
+            const maxAge = 30 * 24 * 60 * 60 * 1000; // 30 days in milliseconds
+            if (Date.now() - cookieDate.getTime() > maxAge) {
+                this.clearLastLocation();
+                return null;
+            }
+            
+            return locationData;
+        } catch (error) {
+            console.error('❌ Failed to parse location cookie:', error);
+            this.clearLastLocation();
+            return null;
+        }
+    }
+
+    // Clear last location
+    static clearLastLocation() {
+        CookieManager.deleteCookie(this.COOKIE_NAME);
+        console.log('🗑️ Location cookie cleared');
+    }
+
+    // Check if location cookie exists
+    static hasLastLocation() {
+        return this.getLastLocation() !== null;
+    }
+}
+
+// Export for use in other scripts
+window.CookieManager = CookieManager;
+window.LocationCookieManager = LocationCookieManager;
diff --git a/public/js/dashboard.js b/public/js/dashboard.js
new file mode 100644
index 0000000..6cd842f
--- /dev/null
+++ b/public/js/dashboard.js
@@ -0,0 +1,2163 @@
+// Supabase configuration
+const SUPABASE_URL = 'https://lfxlplnypzvjrhftaoog.supabase.co';
+const SUPABASE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImxmeGxwbG55cHp2anJoZnRhb29nIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDkyMTQ3NzIsImV4cCI6MjA2NDc5MDc3Mn0.XR4preBqWAQ1rT4PFbpkmRdz57BTwIusBI89fIxDHM8';
+
+// Initialize Supabase client
+const supabase = window.supabase.createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
+
+// Global variables
+let currentUser = null;
+let currentLanguage = 'en'; // Default to English
+
+// Check authentication and load dashboard
+async function initDashboard() {
+    try {
+        // Get current session
+        const { data: { session }, error } = await supabase.auth.getSession();
+
+        if (error) {
+            console.error('Error checking authentication:', error);
+            // Temporarily show dashboard for testing
+            currentUser = { id: '9966cffd-2088-423c-b852-0ca7996cda97', email: 'admin@speedrun-arena.com' };
+            displayUserInfo({ email: 'admin@speedrun-arena.com' });
+            showDashboard();
+            // Check times section
+            checkLinkStatusAndLoadTimes();
+            return;
+        }
+
+        if (!session) {
+            // No session, redirect to login
+            window.location.href = '/login';
+            return;
+        }
+
+        // User is authenticated, show dashboard
+        if (session.user) {
+            
+            currentUser = session.user;
+            displayUserInfo(session.user);
+        } else {
+            // Fallback if no user data
+            currentUser = { id: '9966cffd-2088-423c-b852-0ca7996cda97', email: 'admin@speedrun-arena.com' };
+            displayUserInfo({ email: 'admin@speedrun-arena.com' });
+        }
+        showDashboard();
+
+        // Load times section
+        checkLinkStatusAndLoadTimes();
+        
+        // Update analytics and statistics cards
+        updateAnalyticsAndStatisticsCards();
+
+    } catch (error) {
+        console.error('An unexpected error occurred:', error);
+        // window.location.href = '/login';
+    }
+}
+
+// Display user information
+function displayUserInfo(user) {
+    const userEmail = document.getElementById('userEmail');
+    const userAvatar = document.getElementById('userAvatar');
+
+    userEmail.textContent = user.email;
+    userAvatar.textContent = user.email.charAt(0).toUpperCase();
+}
+
+// Show dashboard content
+function showDashboard() {
+    document.getElementById('loading').style.display = 'none';
+    document.getElementById('dashboardContent').style.display = 'block';
+}
+
+// Logout function
+async function logout() {
+    try {
+        const { error } = await supabase.auth.signOut();
+        if (error) {
+            console.error('Error logging out:', error);
+        } else {
+            window.location.href = '/';
+        }
+    } catch (error) {
+        console.error('Error during logout:', error);
+    }
+}
+
+// Listen for auth state changes
+supabase.auth.onAuthStateChange((event, session) => {
+    if (event === 'SIGNED_OUT' || !session) {
+        window.location.href = '/login';
+    }
+});
+
+// Language Management
+function translateElement(element, language) {
+    if (element.dataset[language]) {
+        // Check if the content contains HTML tags
+        if (element.dataset[language].includes('<')) {
+            element.innerHTML = element.dataset[language];
+        } else {
+            element.textContent = element.dataset[language];
+        }
+    }
+}
+
+// Change language function
+function changeLanguage() {
+    const languageSelect = document.getElementById('languageSelect');
+    currentLanguage = languageSelect.value;
+
+    // Save language preference
+    localStorage.setItem('ninjacross_language', currentLanguage);
+
+    // Update flag in select
+    updateLanguageFlag();
+
+    // Translate all elements with data attributes
+    const elementsToTranslate = document.querySelectorAll('[data-de][data-en]');
+    elementsToTranslate.forEach(element => {
+        translateElement(element, currentLanguage);
+    });
+
+    // Update dynamic content
+    updateDynamicContent();
+
+    console.log(`🌐 Language changed to: ${currentLanguage}`);
+}
+
+// Update flag in language selector
+function updateLanguageFlag() {
+    const languageSelect = document.getElementById('languageSelect');
+    if (languageSelect) {
+        if (currentLanguage === 'de') {
+            // German flag (black-red-gold)
+            languageSelect.style.backgroundImage = `url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="20" height="15" viewBox="0 0 20 15"><rect width="20" height="5" fill="%23000000"/><rect y="5" width="20" height="5" fill="%23DD0000"/><rect y="10" width="20" height="5" fill="%23FFCE00"/></svg>')`;
+        } else {
+            // USA flag
+            languageSelect.style.backgroundImage = `url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="20" height="15" viewBox="0 0 20 15"><rect width="20" height="15" fill="%23B22234"/><rect width="20" height="1.15" fill="%23FFFFFF"/><rect y="2.3" width="20" height="1.15" fill="%23FFFFFF"/><rect y="4.6" width="20" height="1.15" fill="%23FFFFFF"/><rect y="6.9" width="20" height="1.15" fill="%23FFFFFF"/><rect y="9.2" width="20" height="1.15" fill="%23FFFFFF"/><rect y="11.5" width="20" height="1.15" fill="%23FFFFFF"/><rect y="13.8" width="20" height="1.15" fill="%23FFFFFF"/><rect width="7.7" height="8.05" fill="%230033A0"/></svg>')`;
+        }
+    }
+}
+
+// Update dynamic content that's not in HTML
+function updateDynamicContent() {
+    // Update achievement notifications
+    updateAchievementNotifications();
+
+    // Update time display formats
+    updateTimeDisplayFormats();
+
+    // Update achievement progress text
+    updateAchievementProgressText();
+    
+    // Update analytics and statistics cards
+    updateAnalyticsAndStatisticsCards();
+
+    // Reload achievements if they're loaded
+    if (window.allAchievements && window.allAchievements.length > 0) {
+        displayAchievements();
+    }
+
+    // Reload times if they're loaded
+    if (document.getElementById('timesDisplay').style.display !== 'none') {
+        // Times are displayed, reload them
+        checkLinkStatusAndLoadTimes();
+    }
+}
+
+// Load saved language preference
+function loadLanguagePreference() {
+    const savedLanguage = localStorage.getItem('ninjacross_language');
+    if (savedLanguage && (savedLanguage === 'de' || savedLanguage === 'en')) {
+        currentLanguage = savedLanguage;
+        const languageSelect = document.getElementById('languageSelect');
+        if (languageSelect) {
+            languageSelect.value = currentLanguage;
+            // Update flag when loading
+            updateLanguageFlag();
+        }
+    }
+}
+
+// Update analytics and statistics cards based on link status
+function updateAnalyticsAndStatisticsCards() {
+    const analyticsCard = document.getElementById('analyticsCard');
+    const statisticsCard = document.getElementById('statisticsCard');
+    
+    if (!currentPlayerId) {
+        // User not linked - show appropriate message
+        if (analyticsCard) {
+            const isGerman = currentLanguage === 'de';
+            const message = isGerman ? 
+                'RFID verknüpfen erforderlich' : 
+                'RFID linking required';
+            const description = isGerman ?
+                'Verknüpfe deine RFID-Karte, um Analytics zu sehen.' :
+                'Link your RFID card to view analytics.';
+            
+            analyticsCard.innerHTML = `
+                <h3>📊 Analytics</h3>
+                <div style="background: rgba(239, 68, 68, 0.1); border: 1px solid rgba(239, 68, 68, 0.3); border-radius: 0.5rem; padding: 1rem; margin: 1rem 0;">
+                    <div style="display: flex; align-items: center; gap: 0.5rem; margin-bottom: 0.5rem;">
+                        <span style="color: #ef4444; font-weight: 600;">⚠️</span>
+                        <span style="color: #ef4444; font-weight: 600;">${message}</span>
+                    </div>
+                    <div style="font-size: 0.9rem; color: #8892b0;">
+                        ${description}
+                    </div>
+                </div>
+                <button class="btn btn-primary" style="margin-top: 1rem;" onclick="event.stopPropagation(); showRFIDSettings();" data-de="RFID verknüpfen" data-en="Link RFID">RFID verknüpfen</button>
+            `;
+        }
+        
+        if (statisticsCard) {
+            const isGerman = currentLanguage === 'de';
+            const message = isGerman ? 
+                'RFID verknüpfen erforderlich' : 
+                'RFID linking required';
+            const description = isGerman ?
+                'Verknüpfe deine RFID-Karte, um Statistiken zu sehen.' :
+                'Link your RFID card to view statistics.';
+            
+            statisticsCard.innerHTML = `
+                <h3>📊 Statistiken</h3>
+                <div style="background: rgba(239, 68, 68, 0.1); border: 1px solid rgba(239, 68, 68, 0.3); border-radius: 0.5rem; padding: 1rem; margin: 1rem 0;">
+                    <div style="display: flex; align-items: center; gap: 0.5rem; margin-bottom: 0.5rem;">
+                        <span style="color: #ef4444; font-weight: 600;">⚠️</span>
+                        <span style="color: #ef4444; font-weight: 600;">${message}</span>
+                    </div>
+                    <div style="font-size: 0.9rem; color: #8892b0;">
+                        ${description}
+                    </div>
+                </div>
+                <button class="btn btn-primary" style="margin-top: 1rem;" onclick="event.stopPropagation(); showRFIDSettings();" data-de="RFID verknüpfen" data-en="Link RFID">RFID verknüpfen</button>
+            `;
+        }
+    } else {
+        // User is linked - restore original cards
+        if (analyticsCard) {
+            const isGerman = currentLanguage === 'de';
+            analyticsCard.innerHTML = `
+                <h3>📊 Analytics</h3>
+                <div id="analyticsPreview" style="display: none;">
+                    <div class="analytics-stats">
+                        <div class="mini-stat">
+                            <div class="mini-stat-number" id="avgTimeThisWeek">--:--</div>
+                            <div class="mini-stat-label">${isGerman ? 'Durchschnitt diese Woche' : 'Average this week'}</div>
+                        </div>
+                        <div class="mini-stat">
+                            <div class="mini-stat-number" id="improvementThisWeek">+0.0%</div>
+                            <div class="mini-stat-label">${isGerman ? 'Verbesserung' : 'Improvement'}</div>
+                        </div>
+                        <div class="mini-stat">
+                            <div class="mini-stat-number" id="runsThisWeek">0</div>
+                            <div class="mini-stat-label">${isGerman ? 'Läufe diese Woche' : 'Runs this week'}</div>
+                        </div>
+                    </div>
+                </div>
+                <p>${isGerman ? 'Verfolge deine Leistung und überwache wichtige Metriken.' : 'Track your performance and monitor important metrics.'}</p>
+                <button class="btn btn-primary" style="margin-top: 1rem;" onclick="event.stopPropagation(); showAnalytics();" data-de="Analytics öffnen" data-en="Open Analytics">${isGerman ? 'Analytics öffnen' : 'Open Analytics'}</button>
+            `;
+        }
+        
+        if (statisticsCard) {
+            const isGerman = currentLanguage === 'de';
+            statisticsCard.innerHTML = `
+                <h3>📊 Statistiken</h3>
+                <div id="statisticsPreview" style="display: none;">
+                    <div class="statistics-stats">
+                        <div class="mini-stat">
+                            <div class="mini-stat-number" id="personalBest">--:--</div>
+                            <div class="mini-stat-label">${isGerman ? 'Persönliche Bestzeit' : 'Personal Best'}</div>
+                        </div>
+                        <div class="mini-stat">
+                            <div class="mini-stat-number" id="totalRunsCount">0</div>
+                            <div class="mini-stat-label">${isGerman ? 'Gesamte Läufe' : 'Total Runs'}</div>
+                        </div>
+                        <div class="mini-stat">
+                            <div class="mini-stat-number" id="rankPosition">-</div>
+                            <div class="mini-stat-label">${isGerman ? 'Ranglisten-Position' : 'Ranking Position'}</div>
+                        </div>
+                    </div>
+                </div>
+                <p>${isGerman ? 'Detaillierte Statistiken zu deinen Läufen - beste Zeiten, Verbesserungen und Vergleiche.' : 'Detailed statistics about your runs - best times, improvements and comparisons.'}</p>
+                <button class="btn btn-primary" style="margin-top: 1rem;" onclick="event.stopPropagation(); showStatistics();" data-de="Statistiken öffnen" data-en="Open Statistics">${isGerman ? 'Statistiken öffnen' : 'Open Statistics'}</button>
+            `;
+        }
+    }
+}
+
+// Update achievement notifications
+function updateAchievementNotifications() {
+    // This will be called when achievements are displayed
+}
+
+// Update time display formats
+function updateTimeDisplayFormats() {
+    // This will be called when times are displayed
+}
+
+// Update achievement progress text
+function updateAchievementProgressText() {
+    // This will be called when achievements are displayed
+}
+
+// Achievement translations are now handled by the database
+
+// Translate achievement data using database translations
+function translateAchievement(achievement) {
+    if (currentLanguage === 'en' && achievement.name_en) {
+        return {
+            ...achievement,
+            name: achievement.name_en,
+            description: achievement.description_en || achievement.description
+        };
+    }
+    return achievement;
+}
+
+
+// Initialize dashboard when page loads
+document.addEventListener('DOMContentLoaded', function () {
+    loadLanguagePreference();
+    changeLanguage(); // Apply saved language
+    initDashboard();
+    
+    // Push notifications are now handled manually via the button
+    // No automatic subscription on page load
+});
+
+// Modal functions
+function openModal(modalId) {
+    document.getElementById(modalId).style.display = 'block';
+}
+
+function closeModal(modalId) {
+    document.getElementById(modalId).style.display = 'none';
+    // Reset modal state
+    if (modalId === 'rfidModal') {
+        stopQRScanner();
+        document.getElementById('manualRfidInput').value = '';
+    }
+}
+
+// Close modal when clicking outside
+window.onclick = function (event) {
+    if (event.target.classList.contains('modal')) {
+        closeModal(event.target.id);
+    }
+}
+
+// QR Scanner variables
+let qrStream = null;
+let qrScanning = false;
+
+// Show RFID Settings
+async function showRFIDSettings() {
+    openModal('rfidModal');
+    // Reset scanner state
+    stopQRScanner();
+
+    // Check if user is already linked and hide/show create player section
+    await updateCreatePlayerSectionVisibility();
+}
+
+// Update visibility of create player section based on link status
+async function updateCreatePlayerSectionVisibility() {
+    const createPlayerSection = document.getElementById('createPlayerSection');
+
+    if (!currentUser) {
+        // No user logged in - hide create player section
+        if (createPlayerSection) {
+            createPlayerSection.style.display = 'none';
+        }
+        return;
+    }
+
+    try {
+        // Check if user has a linked player
+        const response = await fetch(`/api/v1/public/user-player/${currentUser.id}?t=${Date.now()}`);
+
+        if (response.ok) {
+            const result = await response.json();
+            if (result.success && result.data && result.data.id) {
+                // User is already linked - hide create player section
+                if (createPlayerSection) {
+                    createPlayerSection.style.display = 'none';
+                }
+            } else {
+                // User is not linked - show create player section
+                if (createPlayerSection) {
+                    createPlayerSection.style.display = 'block';
+                }
+            }
+        } else {
+            // Error checking link status - show create player section as fallback
+            if (createPlayerSection) {
+                createPlayerSection.style.display = 'block';
+            }
+        }
+    } catch (error) {
+        console.error('Error checking link status:', error);
+        // Error occurred - show create player section as fallback
+        if (createPlayerSection) {
+            createPlayerSection.style.display = 'block';
+        }
+    }
+}
+
+// Check link status and load times
+async function checkLinkStatusAndLoadTimes() {
+    if (!currentUser) {
+        showTimesNotLinked();
+        return;
+    }
+
+    try {
+        // Check if user has a linked player
+        const response = await fetch(`/api/v1/public/user-player/${currentUser.id}?t=${Date.now()}`);
+
+        if (response.ok) {
+            const result = await response.json();
+            // User is linked, load times
+            await loadUserTimesSection(result.data);
+
+        } else {
+            // User is not linked
+            showTimesNotLinked();
+        }
+    } catch (error) {
+        console.error('Error checking link status:', error);
+        showTimesNotLinked();
+    }
+}
+
+// Start QR Scanner
+async function startQRScanner() {
+    try {
+        // Request camera access
+        qrStream = await navigator.mediaDevices.getUserMedia({
+            video: {
+                facingMode: 'environment', // Use back camera if available
+                width: { ideal: 1280 },
+                height: { ideal: 720 }
+            }
+        });
+
+        const video = document.getElementById('qrVideo');
+        const canvas = document.getElementById('qrCanvas');
+        const context = canvas.getContext('2d');
+
+        video.srcObject = qrStream;
+        video.play();
+
+        // Show camera container and update buttons
+        document.getElementById('cameraContainer').style.display = 'block';
+        document.getElementById('startScanBtn').style.display = 'none';
+        document.getElementById('stopScanBtn').style.display = 'inline-block';
+        document.getElementById('scanningStatus').style.display = 'block';
+
+        qrScanning = true;
+
+        // Start scanning loop
+        video.addEventListener('loadedmetadata', () => {
+            canvas.width = video.videoWidth;
+            canvas.height = video.videoHeight;
+            scanQRCode();
+        });
+
+    } catch (error) {
+        console.error('Error accessing camera:', error);
+        const cameraErrorMsg = currentLanguage === 'de' ?
+            'Kamera-Zugriff fehlgeschlagen. Bitte verwende die manuelle Eingabe.' :
+            'Camera access failed. Please use manual input.';
+        showMessage('rfidMessage', cameraErrorMsg, 'error');
+    }
+}
+
+// Stop QR Scanner
+function stopQRScanner() {
+    qrScanning = false;
+
+    if (qrStream) {
+        qrStream.getTracks().forEach(track => track.stop());
+        qrStream = null;
+    }
+
+    // Reset UI
+    document.getElementById('cameraContainer').style.display = 'none';
+    document.getElementById('startScanBtn').style.display = 'inline-block';
+    document.getElementById('stopScanBtn').style.display = 'none';
+    document.getElementById('scanningStatus').style.display = 'none';
+}
+
+// Scan QR Code from video stream
+function scanQRCode() {
+    if (!qrScanning) return;
+
+    const video = document.getElementById('qrVideo');
+    const canvas = document.getElementById('qrCanvas');
+    const context = canvas.getContext('2d');
+
+    if (video.readyState === video.HAVE_ENOUGH_DATA) {
+        canvas.width = video.videoWidth;
+        canvas.height = video.videoHeight;
+        context.drawImage(video, 0, 0, canvas.width, canvas.height);
+
+        const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
+        const code = jsQR(imageData.data, imageData.width, imageData.height);
+
+        if (code) {
+            console.log('QR Code detected:', code.data);
+            handleQRCodeDetected(code.data);
+            return;
+        }
+    }
+
+    // Continue scanning
+    if (qrScanning) {
+        requestAnimationFrame(scanQRCode);
+    }
+}
+
+// Format RFID UID to match database format
+function formatRfidUid(rawUid) {
+    // Remove any existing formatting (spaces, colons, etc.)
+    let cleanUid = rawUid.replace(/[^a-fA-F0-9]/g, '').toUpperCase();
+
+    // Handle different UID lengths
+    if (cleanUid.length === 6) {
+        // Pad 6-digit UID to 8 digits by adding leading zeros
+        cleanUid = '00' + cleanUid;
+    } else if (cleanUid.length === 8) {
+        // Already correct length
+    } else if (cleanUid.length < 6) {
+        // Pad shorter UIDs to 8 digits
+        cleanUid = cleanUid.padStart(8, '0');
+    } else {
+        throw new Error(`Ungültige RFID UID Länge: ${cleanUid.length} Zeichen (unterstützt: 6-8)`);
+    }
+
+    // Format as XX:XX:XX:XX
+    return cleanUid.match(/.{2}/g).join(':');
+}
+
+// Handle detected QR code
+async function handleQRCodeDetected(qrData) {
+    stopQRScanner();
+
+    try {
+        // Extract and format RFID UID from QR code
+        const rawUid = qrData.trim();
+
+        if (!rawUid) {
+            const qrErrorMsg = currentLanguage === 'de' ?
+                'QR-Code enthält keine gültige RFID UID' :
+                'QR code contains no valid RFID UID';
+            showMessage('rfidMessage', qrErrorMsg, 'error');
+            return;
+        }
+
+        // Format the UID to match database format (XX:XX:XX:XX)
+        const formattedUid = formatRfidUid(rawUid);
+
+        const qrDetectedMsg = currentLanguage === 'de' ?
+            `QR-Code erkannt: ${rawUid} → ${formattedUid}` :
+            `QR code detected: ${rawUid} → ${formattedUid}`;
+        showMessage('rfidMessage', qrDetectedMsg, 'info');
+
+        // Link the user using the formatted RFID UID
+        await linkUserByRfidUid(formattedUid);
+
+    } catch (error) {
+        console.error('Error formatting RFID UID:', error);
+        const formatErrorMsg = currentLanguage === 'de' ?
+            `Fehler beim Formatieren der RFID UID: ${error.message}` :
+            `Error formatting RFID UID: ${error.message}`;
+        showMessage('rfidMessage', formatErrorMsg, 'error');
+    }
+}
+
+// Manual RFID linking
+async function linkManualRfid() {
+    const rawUid = document.getElementById('manualRfidInput').value.trim();
+
+    if (!rawUid) {
+        const inputErrorMsg = currentLanguage === 'de' ?
+            'Bitte gib eine RFID UID ein' :
+            'Please enter a RFID UID';
+        showMessage('rfidMessage', inputErrorMsg, 'error');
+        return;
+    }
+
+    try {
+        // Format the UID to match database format
+        const formattedUid = formatRfidUid(rawUid);
+
+        const formattedMsg = currentLanguage === 'de' ?
+            `Formatiert: ${rawUid} → ${formattedUid}` :
+            `Formatted: ${rawUid} → ${formattedUid}`;
+        showMessage('rfidMessage', formattedMsg, 'info');
+
+        await linkUserByRfidUid(formattedUid);
+
+    } catch (error) {
+        console.error('Error formatting manual RFID UID:', error);
+        const formatErrorMsg = currentLanguage === 'de' ?
+            `Fehler beim Formatieren: ${error.message}` :
+            `Error formatting: ${error.message}`;
+        showMessage('rfidMessage', formatErrorMsg, 'error');
+    }
+}
+
+// Create new RFID player record
+async function createRfidPlayerRecord() {
+    const rawUid = document.getElementById('manualRfidInput').value.trim();
+    const firstname = document.getElementById('playerFirstname').value.trim();
+    const lastname = document.getElementById('playerLastname').value.trim();
+    const birthdate = document.getElementById('playerBirthdate').value;
+    const agbAccepted = document.getElementById('agbAccepted').checked;
+
+    // Validation
+    if (!rawUid) {
+        const inputErrorMsg = currentLanguage === 'de' ?
+            'Bitte gib eine RFID UID ein' :
+            'Please enter a RFID UID';
+        showMessage('rfidMessage', inputErrorMsg, 'error');
+        return;
+    }
+
+    if (!firstname) {
+        const inputErrorMsg = currentLanguage === 'de' ?
+            'Bitte gib einen Vornamen ein' :
+            'Please enter a first name';
+        showMessage('rfidMessage', inputErrorMsg, 'error');
+        return;
+    }
+
+    if (!lastname) {
+        const inputErrorMsg = currentLanguage === 'de' ?
+            'Bitte gib einen Nachnamen ein' :
+            'Please enter a last name';
+        showMessage('rfidMessage', inputErrorMsg, 'error');
+        return;
+    }
+
+    if (!birthdate) {
+        const inputErrorMsg = currentLanguage === 'de' ?
+            'Bitte gib ein Geburtsdatum ein' :
+            'Please enter a birth date';
+        showMessage('rfidMessage', inputErrorMsg, 'error');
+        return;
+    }
+
+    if (!agbAccepted) {
+        const agbErrorMsg = currentLanguage === 'de' ?
+            'Bitte stimme den Allgemeinen Geschäftsbedingungen zu' :
+            'Please accept the Terms of Service';
+        showMessage('rfidMessage', agbErrorMsg, 'error');
+        return;
+    }
+
+    try {
+        // Format the UID to match database format
+        const formattedUid = formatRfidUid(rawUid);
+
+        const formattedMsg = currentLanguage === 'de' ?
+            `Erstelle Spieler: ${firstname} ${lastname} (${formattedUid})` :
+            `Creating player: ${firstname} ${lastname} (${formattedUid})`;
+        showMessage('rfidMessage', formattedMsg, 'info');
+
+        // Create player record
+        const response = await fetch('/api/v1/public/players/create-with-rfid', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                rfiduid: formattedUid,
+                firstname: firstname,
+                lastname: lastname,
+                birthdate: birthdate,
+                supabase_user_id: currentUser?.id || null,
+                agb_accepted: agbAccepted
+            })
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+            const successMsg = currentLanguage === 'de' ?
+                `Spieler erfolgreich erstellt: ${result.data.firstname} ${result.data.lastname}` :
+                `Player successfully created: ${result.data.firstname} ${result.data.lastname}`;
+            showMessage('rfidMessage', successMsg, 'success');
+
+            // Clear form
+            document.getElementById('manualRfidInput').value = '';
+            document.getElementById('playerFirstname').value = '';
+            document.getElementById('playerLastname').value = '';
+            document.getElementById('playerBirthdate').value = '';
+            document.getElementById('agbAccepted').checked = false;
+
+            // Hide create player section since user is now linked
+            const createPlayerSection = document.getElementById('createPlayerSection');
+            if (createPlayerSection) {
+                createPlayerSection.style.display = 'none';
+            }
+
+            // Refresh times if user is linked
+            if (currentUser) {
+                await checkLinkStatusAndLoadTimes();
+            }
+        } else {
+            let errorMsg = result.message;
+
+            // Erweitere Fehlermeldung um Levenshtein-Details falls vorhanden
+            if (result.details) {
+                if (result.details.matchType === 'similar') {
+                    const similarityPercent = Math.round((1 - result.details.similarity) * 100);
+                    errorMsg += `\n\nÄhnlichkeit: ${similarityPercent}% (Distanz: ${result.details.levenshteinDistance})`;
+                }
+            }
+
+            showMessage('rfidMessage', errorMsg, 'error');
+        }
+
+    } catch (error) {
+        console.error('Error creating RFID player record:', error);
+        const errorMsg = currentLanguage === 'de' ?
+            `Fehler beim Erstellen: ${error.message}` :
+            `Error creating: ${error.message}`;
+        showMessage('rfidMessage', errorMsg, 'error');
+    }
+}
+
+// Link user by RFID UID (core function)
+async function linkUserByRfidUid(rfidUid) {
+    if (!currentUser) {
+        const authErrorMsg = currentLanguage === 'de' ?
+            'Benutzer nicht authentifiziert' :
+            'User not authenticated';
+        showMessage('rfidMessage', authErrorMsg, 'error');
+        return;
+    }
+
+    try {
+        // First, find the player with this RFID UID
+        const response = await fetch('/api/v1/public/link-by-rfid', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                rfiduid: rfidUid,
+                supabase_user_id: currentUser.id
+            })
+        });
+
+        const result = await response.json();
+
+        if (response.ok) {
+            const successMsg = currentLanguage === 'de' ?
+                `✅ RFID erfolgreich verknüpft!\nSpieler: ${result.data.firstname} ${result.data.lastname}` :
+                `✅ RFID successfully linked!\nPlayer: ${result.data.firstname} ${result.data.lastname}`;
+            showMessage('rfidMessage', successMsg, 'success');
+            setTimeout(() => {
+                closeModal('rfidModal');
+                // Reload times section after successful linking
+                checkLinkStatusAndLoadTimes();
+            }, 2000);
+        } else {
+            const errorMsg = currentLanguage === 'de' ?
+                result.message || 'Fehler beim Verknüpfen' :
+                result.message || 'Error linking';
+            showMessage('rfidMessage', errorMsg, 'error');
+        }
+    } catch (error) {
+        console.error('Error linking RFID:', error);
+        const linkErrorMsg = currentLanguage === 'de' ?
+            'Fehler beim Verknüpfen der RFID' :
+            'Error linking RFID';
+        showMessage('rfidMessage', linkErrorMsg, 'error');
+    }
+}
+
+// Show not linked state
+function showTimesNotLinked() {
+    document.getElementById('timesLoading').style.display = 'none';
+    document.getElementById('timesNotLinked').style.display = 'block';
+    document.getElementById('timesDisplay').style.display = 'none';
+
+    // Update the text content for the not linked state
+    const notLinkedTitle = document.querySelector('#timesNotLinked h3');
+    const notLinkedDescription = document.querySelector('#timesNotLinked p');
+    const notLinkedButton = document.querySelector('#timesNotLinked button');
+    const notLinkedSteps = document.querySelectorAll('#timesNotLinked li');
+
+    if (notLinkedTitle) {
+        notLinkedTitle.textContent = currentLanguage === 'de' ?
+            'RFID noch nicht verknüpft' :
+            'RFID not linked yet';
+    }
+
+    if (notLinkedDescription) {
+        notLinkedDescription.textContent = currentLanguage === 'de' ?
+            'Um deine persönlichen Zeiten zu sehen, musst du zuerst deine RFID-Karte mit deinem Account verknüpfen.' :
+            'To see your personal times, you must first link your RFID card with your account.';
+    }
+
+    if (notLinkedButton) {
+        notLinkedButton.textContent = currentLanguage === 'de' ?
+            '🏷️ RFID jetzt verknüpfen' :
+            '🏷️ Link RFID now';
+    }
+
+    if (notLinkedSteps.length >= 3) {
+        notLinkedSteps[0].textContent = currentLanguage === 'de' ?
+            'Klicke auf "RFID jetzt verknüpfen"' :
+            'Click on "Link RFID now"';
+        notLinkedSteps[1].textContent = currentLanguage === 'de' ?
+            'Scanne den QR-Code auf deiner RFID-Karte' :
+            'Scan the QR code on your RFID card';
+        notLinkedSteps[2].textContent = currentLanguage === 'de' ?
+            'Fertig! Deine Zeiten werden automatisch hier angezeigt' :
+            'Done! Your times will be displayed here automatically';
+    }
+
+    // Update the "So funktioniert's" title
+    const howItWorksTitle = document.querySelector('#timesNotLinked h4');
+    if (howItWorksTitle) {
+        howItWorksTitle.textContent = currentLanguage === 'de' ?
+            'So funktioniert\'s:' :
+            'How it works:';
+    }
+}
+
+// Show RFID linked info with help button
+function showRFIDLinkedInfo(playerData) {
+    // Find the RFID card and update it
+    const rfidCard = document.querySelector('.card[onclick="showRFIDSettings()"]');
+    if (rfidCard) {
+        const isGerman = currentLanguage === 'de';
+        
+        rfidCard.innerHTML = `
+            <h3>${isGerman ? '🏷️ RFID Verknüpft' : '🏷️ RFID Linked'}</h3>
+            <div style="background: rgba(16, 185, 129, 0.1); border: 1px solid rgba(16, 185, 129, 0.3); border-radius: 0.5rem; padding: 1rem; margin: 1rem 0;">
+                <div style="display: flex; align-items: center; gap: 0.5rem; margin-bottom: 0.5rem;">
+                    <span style="color: #10b981; font-weight: 600;">✅</span>
+                    <span style="color: #10b981; font-weight: 600;">
+                        ${isGerman ? 'Erfolgreich verknüpft' : 'Successfully linked'}
+                    </span>
+                </div>
+                <div style="font-size: 0.9rem; color: #8892b0;">
+                    <div><strong>${isGerman ? 'Spieler:' : 'Player:'}</strong> ${playerData.firstname} ${playerData.lastname}</div>
+                    <div><strong>RFID:</strong> <code style="background: rgba(255,255,255,0.1); padding: 0.2rem 0.4rem; border-radius: 0.25rem; font-family: monospace;">${playerData.rfiduid}</code></div>
+                </div>
+            </div>
+            <button class="btn btn-secondary" onclick="requestRFIDHelp()" style="margin-top: 1rem; font-size: 0.9rem; padding: 0.5rem 1rem;">
+                ${isGerman ? '❓ Hilfe anfordern' : '❓ Request Help'}
+            </button>
+        `;
+        
+        // Remove the onclick from the card since we don't want it to open the modal
+        rfidCard.removeAttribute('onclick');
+        rfidCard.style.cursor = 'default';
+    }
+}
+
+// Request RFID help
+function requestRFIDHelp() {
+    const isGerman = currentLanguage === 'de';
+    const message = isGerman ? 
+        'Hilfe-Anfrage gesendet! Ein Administrator wird sich bei dir melden, um bei der RFID-Änderung zu helfen.' :
+        'Help request sent! An administrator will contact you to help with the RFID change.';
+    
+    alert(message);
+    
+    // Here you could send a notification to admins or log the help request
+    console.log('RFID help requested by user:', currentUser?.email);
+}
+
+// Show loading state
+function showTimesLoading() {
+    document.getElementById('timesLoading').style.display = 'block';
+    document.getElementById('timesNotLinked').style.display = 'none';
+    document.getElementById('timesDisplay').style.display = 'none';
+
+    // Update the loading text
+    const loadingText = document.querySelector('#timesLoading p');
+    if (loadingText) {
+        loadingText.textContent = currentLanguage === 'de' ?
+            'Lade deine Zeiten...' :
+            'Loading your times...';
+    }
+}
+
+// Load user times for the section
+async function loadUserTimesSection(playerData) {
+    showTimesLoading();
+
+    try {
+        const response = await fetch(`/api/v1/public/user-times/${currentUser.id}?t=${Date.now()}`);
+        const result = await response.json();
+
+        if (!response.ok) {
+            throw new Error(result.message || 'Failed to load times');
+        }
+
+        const times = result.data || result;
+
+        // Update stats
+        updateTimesStats(times, playerData);
+
+        // Display times
+        displayUserTimes(times);
+
+        // Show RFID info and help button
+        showRFIDLinkedInfo(playerData);
+
+        // Show the times display
+        document.getElementById('timesLoading').style.display = 'none';
+        document.getElementById('timesNotLinked').style.display = 'none';
+        document.getElementById('timesDisplay').style.display = 'block';
+
+        // Initialize achievements for this player
+        initializeAchievements(playerData.id);
+        
+        // Update analytics and statistics cards (user is now linked)
+        updateAnalyticsAndStatisticsCards();
+
+    } catch (error) {
+        console.error('Error loading user times:', error);
+        showTimesNotLinked();
+    }
+}
+
+// Update stats cards
+function updateTimesStats(times, playerData) {
+    // Total runs
+    document.getElementById('totalRuns').textContent = times.length;
+
+    // Best time
+    if (times.length > 0) {
+        const bestTimeValue = times.reduce((best, current) => {
+            const currentSeconds = convertTimeToSeconds(current.recorded_time);
+            const bestSeconds = convertTimeToSeconds(best.recorded_time);
+            return currentSeconds < bestSeconds ? current : best;
+        });
+        document.getElementById('bestTime').textContent = formatTime(bestTimeValue.recorded_time);
+    } else {
+        document.getElementById('bestTime').textContent = '--:--';
+    }
+
+    // Unique locations count
+    const uniqueLocations = [...new Set(times.map(time => time.location_name))];
+    document.getElementById('locationsCount').textContent = uniqueLocations.length;
+
+    // Linked player name
+    document.getElementById('linkedPlayer').textContent = `${playerData.firstname} ${playerData.lastname}`;
+}
+
+// Display user times in grid
+function displayUserTimes(times) {
+    const timesGrid = document.getElementById('userTimesGrid');
+
+    if (times.length === 0) {
+        const noTimesTitle = currentLanguage === 'de' ? 'Noch keine Zeiten aufgezeichnet' : 'No times recorded yet';
+        const noTimesDescription = currentLanguage === 'de' ?
+            'Deine ersten Läufe werden hier angezeigt, sobald du sie abgeschlossen hast!' :
+            'Your first runs will be displayed here as soon as you complete them!';
+
+        timesGrid.innerHTML = `
+            <div style="grid-column: 1 / -1; text-align: center; padding: 3rem; color: #8892b0;">
+                <h3>${noTimesTitle}</h3>
+                <p>${noTimesDescription}</p>
+            </div>
+        `;
+        return;
+    }
+
+    // Group times by location
+    const timesByLocation = times.reduce((acc, time) => {
+        if (!acc[time.location_name]) {
+            acc[time.location_name] = [];
+        }
+        acc[time.location_name].push(time);
+        return acc;
+    }, {});
+
+    // Generate cards for each location
+    const cards = Object.entries(timesByLocation).map(([locationName, locationTimes], index) => {
+        // Sort times by performance (best first)
+        const sortedTimes = locationTimes.sort((a, b) => {
+            return convertTimeToSeconds(a.recorded_time) - convertTimeToSeconds(b.recorded_time);
+        });
+
+        // Get best time for this location
+        const bestTime = sortedTimes[0];
+
+        // Generate all runs for expanded view
+        const allRunsHtml = sortedTimes.map((run, runIndex) => {
+            let rankBadge = '';
+            let rankClass = '';
+
+            if (runIndex === 0) {
+                rankBadge = currentLanguage === 'de' ? '🥇 Beste' : '🥇 Best';
+                rankClass = 'best';
+            } else if (runIndex === 1) {
+                rankBadge = '🥈 2.';
+                rankClass = 'second';
+            } else if (runIndex === 2) {
+                rankBadge = '🥉 3.';
+                rankClass = 'third';
+            } else {
+                rankBadge = `${runIndex + 1}.`;
+                rankClass = '';
+            }
+
+            return `
+                <div class="run-item">
+                    <div>
+                        <div class="run-time">${formatTime(run.recorded_time)}</div>
+                    </div>
+                    <div class="run-details">
+                        <div>${new Date(run.created_at).toLocaleDateString(currentLanguage === 'de' ? 'de-DE' : 'en-US')}</div>
+                        <div>${new Date(run.created_at).toLocaleTimeString(currentLanguage === 'de' ? 'de-DE' : 'en-US', { hour: '2-digit', minute: '2-digit' })}</div>
+                        <span class="run-rank-badge ${rankClass}">${rankBadge}</span>
+                    </div>
+                </div>
+            `;
+        }).join('');
+
+        return `
+            <div class="user-time-card" onclick="toggleTimeCard(this)" data-location="${locationName}">
+                <div class="card-header">
+                    <div class="time-location-name">${locationName}</div>
+                    <div class="expand-indicator">▼</div>
+                </div>
+                
+                <div class="card-main-content">
+                    <div class="time-value-large">${formatTime(bestTime.recorded_time)}</div>
+                    <div class="time-date-info">
+                        <span>${new Date(bestTime.created_at).toLocaleDateString(currentLanguage === 'de' ? 'de-DE' : 'en-US')}</span>
+                        <span class="time-rank">${locationTimes.length} ${currentLanguage === 'de' ? 'Läufe' : 'Runs'}</span>
+                    </div>
+                </div>
+                
+                <div class="expanded-content">
+                    <div class="all-runs-title">${currentLanguage === 'de' ? 'Alle Läufe an diesem Standort:' : 'All runs at this location:'}</div>
+                    ${allRunsHtml}
+                </div>
+            </div>
+        `;
+    }).join('');
+
+    timesGrid.innerHTML = cards;
+}
+
+// Toggle time card expansion
+function toggleTimeCard(cardElement) {
+    const isExpanded = cardElement.classList.contains('expanded');
+
+    // Close all other cards first
+    document.querySelectorAll('.user-time-card.expanded').forEach(card => {
+        if (card !== cardElement) {
+            card.classList.remove('expanded');
+        }
+    });
+
+    // Toggle current card
+    if (isExpanded) {
+        cardElement.classList.remove('expanded');
+    } else {
+        cardElement.classList.add('expanded');
+    }
+}
+
+// Helper function to convert time to seconds for comparison
+function convertTimeToSeconds(timeValue) {
+    if (typeof timeValue === 'string') {
+        // Handle HH:MM:SS format
+        const parts = timeValue.split(':');
+        if (parts.length === 3) {
+            return parseInt(parts[0]) * 3600 + parseInt(parts[1]) * 60 + parseFloat(parts[2]);
+        }
+        // Handle MM:SS format
+        if (parts.length === 2) {
+            return parseInt(parts[0]) * 60 + parseFloat(parts[1]);
+        }
+    }
+    return parseFloat(timeValue) || 0;
+}
+
+// Format time interval to readable format
+function formatTime(interval) {
+    // Handle numeric values (seconds)
+    if (typeof interval === 'number') {
+        return formatSeconds(interval);
+    }
+
+    // Postgres interval format: {"hours":0,"minutes":1,"seconds":23.45}
+    if (typeof interval === 'object') {
+        const { hours = 0, minutes = 0, seconds = 0 } = interval;
+        const totalSeconds = hours * 3600 + minutes * 60 + seconds;
+        return formatSeconds(totalSeconds);
+    }
+
+    // Fallback for string format
+    if (typeof interval === 'string') {
+        // Parse format like "00:01:23.45"
+        const parts = interval.split(':');
+        if (parts.length === 3) {
+            const hours = parseInt(parts[0]);
+            const minutes = parseInt(parts[1]);
+            const seconds = parseFloat(parts[2]);
+            const totalSeconds = hours * 3600 + minutes * 60 + seconds;
+            return formatSeconds(totalSeconds);
+        }
+    }
+
+    return interval;
+}
+
+function formatSeconds(totalSeconds) {
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = (totalSeconds % 60).toFixed(2);
+
+    if (minutes > 0) {
+        return `${minutes}:${seconds.padStart(5, '0')}`;
+    } else {
+        return `${seconds}s`;
+    }
+}
+
+// Show message in modal
+function showMessage(containerId, message, type) {
+    const container = document.getElementById(containerId);
+    container.innerHTML = `<div class="message ${type}">${message}</div>`;
+}
+
+// Initialize when DOM is loaded
+// ==================== ACHIEVEMENT FUNCTIONS ====================
+
+// Global variables for achievements
+let currentPlayerId = null;
+let allAchievements = [];
+let playerAchievements = [];
+let currentAchievementCategory = 'all';
+
+// Load achievements for the current player
+async function loadPlayerAchievements() {
+    if (!currentPlayerId || currentPlayerId === 'undefined' || currentPlayerId === 'null') {
+        showAchievementsNotAvailable();
+        return;
+    }
+
+    try {
+        // Show loading state
+        document.getElementById('achievementsLoading').style.display = 'block';
+        document.getElementById('achievementStats').style.display = 'none';
+        document.getElementById('achievementCategories').style.display = 'none';
+        document.getElementById('achievementsNotAvailable').style.display = 'none';
+
+        // Update loading text
+        const loadingText = document.querySelector('#achievementsLoading p');
+        if (loadingText) {
+            loadingText.textContent = currentLanguage === 'de' ?
+                'Lade deine Achievements...' :
+                'Loading your achievements...';
+        }
+
+        // Load player achievements (includes all achievements with player status)
+        const response = await fetch(`/api/achievements/player/${currentPlayerId}?t=${Date.now()}`);
+        if (!response.ok) {
+            throw new Error('Failed to load player achievements');
+        }
+
+        const result = await response.json();
+        
+        
+        window.allAchievements = result.data;
+        playerAchievements = result.data.filter(achievement => achievement.is_completed);
+
+        // Load achievement statistics
+        await loadAchievementStats();
+
+        // Show achievements
+        displayAchievementStats();
+        displayAchievements();
+
+        // Hide loading state
+        document.getElementById('achievementsLoading').style.display = 'none';
+        document.getElementById('achievementStats').style.display = 'flex';
+        document.getElementById('achievementCategories').style.display = 'block';
+
+    } catch (error) {
+        console.error('Error loading achievements:', error);
+        document.getElementById('achievementsLoading').style.display = 'none';
+        showAchievementsNotAvailable();
+    }
+}
+
+// Load achievement statistics
+async function loadAchievementStats() {
+    try {
+        const response = await fetch(`/api/achievements/player/${currentPlayerId}/stats?t=${Date.now()}`);
+        if (response.ok) {
+            const result = await response.json();
+            window.achievementStats = result.data;
+        }
+    } catch (error) {
+        console.error('Error loading achievement stats:', error);
+    }
+}
+
+// Display achievement statistics
+function displayAchievementStats() {
+    if (!window.achievementStats) return;
+
+    const stats = window.achievementStats;
+
+    document.getElementById('totalPoints').textContent = stats.total_points;
+    document.getElementById('completedAchievements').textContent = `${stats.completed_achievements}/${stats.total_achievements}`;
+    document.getElementById('achievementsToday').textContent = stats.achievements_today;
+    document.getElementById('completionPercentage').textContent = `${stats.completion_percentage}%`;
+}
+
+// Display achievements in grid
+function displayAchievements() {
+    const achievementsGrid = document.getElementById('achievementsGrid');
+
+    if (!window.allAchievements || window.allAchievements.length === 0) {
+        const noAchievementsTitle = currentLanguage === 'de' ? 'Noch keine Achievements' : 'No Achievements Yet';
+        const noAchievementsDescription = currentLanguage === 'de' ?
+            'Starte deine ersten Läufe, um Achievements zu sammeln!' :
+            'Start your first runs to collect achievements!';
+
+        achievementsGrid.innerHTML = `
+            <div class="no-achievements">
+                <div class="no-achievements-icon">🏆</div>
+                <h3>${noAchievementsTitle}</h3>
+                <p>${noAchievementsDescription}</p>
+            </div>
+        `;
+        return;
+    }
+
+    // Filter achievements by category
+    let filteredAchievements = window.allAchievements;
+    if (currentAchievementCategory !== 'all') {
+        filteredAchievements = window.allAchievements.filter(achievement =>
+            achievement.category === currentAchievementCategory
+        );
+    }
+
+    // Generate achievement cards
+    const achievementCards = filteredAchievements.map(achievement => {
+        const isCompleted = achievement.is_completed;
+        const progress = achievement.progress || 0;
+        const earnedAt = achievement.earned_at;
+        const completionCount = achievement.completion_count || 0;
+
+        // Translate achievement
+        const translatedAchievement = translateAchievement(achievement);
+
+
+        let progressText = '';
+        if (isCompleted) {
+            const achievedText = currentLanguage === 'de' ? 'Erreicht am' : 'Achieved on';
+            const completedText = currentLanguage === 'de' ? 'Abgeschlossen' : 'Completed';
+            const timesText = currentLanguage === 'de' ? 'x geschafft' : 'x completed';
+            
+            if (completionCount > 1) {
+                progressText = `${completionCount}${timesText}`;
+            } else {
+                progressText = earnedAt ?
+                    `${achievedText} ${new Date(earnedAt).toLocaleDateString(currentLanguage === 'de' ? 'de-DE' : 'en-US')}` :
+                    completedText;
+            }
+        } else if (progress > 0) {
+            // Show progress for incomplete achievements
+            const conditionValue = getAchievementConditionValue(achievement.name);
+            if (conditionValue) {
+                progressText = `${progress}/${conditionValue}`;
+            }
+        }
+
+        const pointsText = currentLanguage === 'de' ? 'Punkte' : 'Points';
+        const totalPoints = completionCount > 0 ? achievement.points * completionCount : achievement.points;
+
+
+        return `
+            <div class="achievement-card ${isCompleted ? 'completed' : 'incomplete'}" 
+                 onclick="showAchievementDetails('${achievement.id}')">
+                <div class="achievement-icon">${achievement.icon}</div>
+                <div class="achievement-content">
+                    <h4 class="achievement-name">${translatedAchievement.name}</h4>
+                    <p class="achievement-description">${translatedAchievement.description}</p>
+                    <div class="achievement-meta">
+                        <span class="achievement-points">+${totalPoints} ${pointsText}</span>
+                        ${progressText ? `<span class="achievement-progress">${progressText}</span>` : ''}
+                    </div>
+                </div>
+                <div class="achievement-status">
+                    ${isCompleted ? '✅' : '⏳'}
+                </div>
+            </div>
+        `;
+    }).join('');
+
+    achievementsGrid.innerHTML = achievementCards;
+}
+
+// Initialize Analytics and Statistics event listeners
+document.addEventListener('DOMContentLoaded', function() {
+    const analyticsCard = document.getElementById('analyticsCard');
+    const statisticsCard = document.getElementById('statisticsCard');
+    
+    if (analyticsCard) {
+        analyticsCard.addEventListener('click', showAnalytics);
+        console.log('Analytics card event listener added');
+    }
+    
+    if (statisticsCard) {
+        statisticsCard.addEventListener('click', showStatistics);
+        console.log('Statistics card event listener added');
+    }
+});
+
+// Analytics Functions
+function showAnalytics() {
+    console.log('showAnalytics called');
+    
+    // Hide other sections
+    const timesDisplay = document.getElementById('timesDisplay');
+    const achievementsDisplay = document.getElementById('achievementsDisplay');
+    const statisticsSection = document.getElementById('statisticsSection');
+    
+    if (timesDisplay) timesDisplay.style.display = 'none';
+    if (achievementsDisplay) achievementsDisplay.style.display = 'none';
+    if (statisticsSection) statisticsSection.style.display = 'none';
+    
+    // Show analytics section
+    const analyticsSection = document.getElementById('analyticsSection');
+    if (analyticsSection) {
+        analyticsSection.style.display = 'block';
+        console.log('Analytics section shown');
+    } else {
+        console.error('Analytics section not found');
+        return;
+    }
+    
+    // Load analytics data (will show fallback if not linked)
+    loadAnalyticsData();
+}
+
+function showStatistics() {
+    console.log('showStatistics called');
+    
+    // Hide other sections
+    const timesDisplay = document.getElementById('timesDisplay');
+    const achievementsDisplay = document.getElementById('achievementsDisplay');
+    const analyticsSection = document.getElementById('analyticsSection');
+    
+    if (timesDisplay) timesDisplay.style.display = 'none';
+    if (achievementsDisplay) achievementsDisplay.style.display = 'none';
+    if (analyticsSection) analyticsSection.style.display = 'none';
+    
+    // Show statistics section
+    const statisticsSection = document.getElementById('statisticsSection');
+    if (statisticsSection) {
+        statisticsSection.style.display = 'block';
+        console.log('Statistics section shown');
+    } else {
+        console.error('Statistics section not found');
+        return;
+    }
+    
+    // Load statistics data (will show fallback if not linked)
+    loadStatisticsData();
+}
+
+async function loadAnalyticsData() {
+    try {
+        if (!currentPlayerId || currentPlayerId === 'undefined' || currentPlayerId === 'null') {
+            console.error('No player ID available - user not linked');
+            // Show fallback data when user is not linked
+            displayAnalyticsFallback();
+            return;
+        }
+
+        // Load analytics data from API
+        const response = await fetch(`/api/analytics/player/${currentPlayerId}`);
+        if (!response.ok) {
+            throw new Error('Failed to load analytics data');
+        }
+        
+        const analyticsData = await response.json();
+        displayAnalyticsData(analyticsData.data);
+        
+        // Update preview in main card
+        updateAnalyticsPreview(analyticsData.data);
+        
+    } catch (error) {
+        console.error('Error loading analytics data:', error);
+        // Show fallback data
+        displayAnalyticsFallback();
+    }
+}
+
+async function loadStatisticsData() {
+    try {
+        if (!currentPlayerId || currentPlayerId === 'undefined' || currentPlayerId === 'null') {
+            console.error('No player ID available - user not linked');
+            // Show fallback data when user is not linked
+            displayStatisticsFallback();
+            return;
+        }
+
+        // Load statistics data from API
+        const response = await fetch(`/api/statistics/player/${currentPlayerId}`);
+        if (!response.ok) {
+            throw new Error('Failed to load statistics data');
+        }
+        
+        const statisticsData = await response.json();
+        displayStatisticsData(statisticsData.data);
+        
+        // Update preview in main card
+        updateStatisticsPreview(statisticsData.data);
+        
+    } catch (error) {
+        console.error('Error loading statistics data:', error);
+        // Show fallback data
+        displayStatisticsFallback();
+    }
+}
+
+function displayAnalyticsData(data) {
+    // Performance Trends
+    document.getElementById('avgTimeThisWeekDetail').textContent = formatTime(data.performance.avgTimeThisWeek);
+    document.getElementById('avgTimeLastWeek').textContent = formatTime(data.performance.avgTimeLastWeek);
+    document.getElementById('improvementDetail').textContent = data.performance.improvement.toFixed(2) + '%';
+    
+    // Activity Stats
+    document.getElementById('runsToday').textContent = data.activity.runsToday + ' Läufe';
+    document.getElementById('runsThisWeekDetail').textContent = data.activity.runsThisWeek + ' Läufe';
+    document.getElementById('avgRunsPerDay').textContent = data.activity.avgRunsPerDay.toFixed(2);
+    
+    // Location Performance
+    displayLocationPerformance(data.locationPerformance);
+    
+    // Monthly Stats
+    document.getElementById('runsThisMonth').textContent = data.monthly.runsThisMonth + ' Läufe';
+    document.getElementById('runsLastMonth').textContent = data.monthly.runsLastMonth + ' Läufe';
+    document.getElementById('bestTimeThisMonth').textContent = formatTime(data.monthly.bestTimeThisMonth);
+}
+
+function displayStatisticsData(data) {
+    // Personal Records
+    displayPersonalRecords(data.personalRecords);
+    
+    // Consistency Metrics
+    document.getElementById('averageTime').textContent = formatTime(data.consistency.averageTime);
+    document.getElementById('timeDeviation').textContent = formatTime(data.consistency.timeDeviation);
+    document.getElementById('consistencyScore').textContent = data.consistency.consistencyScore.toFixed(2) + '%';
+    
+    // Ranking Stats
+    displayRankingStats(data.rankings);
+    
+    // Progress Stats
+    document.getElementById('totalRunsStats').textContent = data.progress.totalRuns;
+    document.getElementById('activeDays').textContent = data.progress.activeDays;
+    document.getElementById('locationsVisited').textContent = data.progress.locationsVisited;
+}
+
+function displayLocationPerformance(locations) {
+    const container = document.getElementById('locationPerformance');
+    
+    if (!locations || locations.length === 0) {
+        container.innerHTML = '<p>Keine Standort-Daten verfügbar</p>';
+        return;
+    }
+    
+    const locationHTML = locations.map(location => `
+        <div class="location-item">
+            <span class="location-name">${location.name}</span>
+            <div>
+                <span class="location-best">${formatTime(location.bestTime)}</span>
+                <span class="location-runs">(${location.runs} Läufe)</span>
+            </div>
+        </div>
+    `).join('');
+    
+    container.innerHTML = locationHTML;
+}
+
+function displayPersonalRecords(records) {
+    const container = document.getElementById('personalRecords');
+    
+    if (!records || records.length === 0) {
+        container.innerHTML = '<p>Keine Bestzeiten verfügbar</p>';
+        return;
+    }
+    
+    const recordsHTML = records.map((record, index) => `
+        <div class="record-item">
+            <div>
+                <span class="record-rank">#${index + 1}</span>
+                <span class="record-time">${formatTime(record.time)}</span>
+            </div>
+            <span class="record-location">${record.location}</span>
+        </div>
+    `).join('');
+    
+    container.innerHTML = recordsHTML;
+}
+
+function displayRankingStats(rankings) {
+    const container = document.getElementById('rankingStats');
+    
+    if (!rankings || rankings.length === 0) {
+        container.innerHTML = '<p>Keine Ranglisten-Daten verfügbar</p>';
+        return;
+    }
+    
+    const rankingsHTML = rankings.map(ranking => `
+        <div class="ranking-item">
+            <span class="ranking-category">${ranking.category}</span>
+            <div>
+                <span class="ranking-position">#${ranking.position}</span>
+                <span class="ranking-total">von ${ranking.total}</span>
+            </div>
+        </div>
+    `).join('');
+    
+    container.innerHTML = rankingsHTML;
+}
+
+function updateAnalyticsPreview(data) {
+    if (data && data.performance && data.activity) {
+        document.getElementById('avgTimeThisWeek').textContent = formatTime(data.performance.avgTimeThisWeek);
+        document.getElementById('improvementThisWeek').textContent = data.performance.improvement.toFixed(2) + '%';
+        document.getElementById('runsThisWeek').textContent = data.activity.runsThisWeek;
+        document.getElementById('analyticsPreview').style.display = 'block';
+    } else {
+        // Hide preview if no data
+        document.getElementById('analyticsPreview').style.display = 'none';
+    }
+}
+
+function updateStatisticsPreview(data) {
+    if (data && data.personalRecords && data.progress) {
+        document.getElementById('personalBest').textContent = formatTime(data.personalRecords[0]?.time || 0);
+        document.getElementById('totalRunsCount').textContent = data.progress.totalRuns;
+        document.getElementById('rankPosition').textContent = data.rankings[0]?.position || '-';
+        document.getElementById('statisticsPreview').style.display = 'block';
+    } else {
+        // Hide preview if no data
+        document.getElementById('statisticsPreview').style.display = 'none';
+    }
+}
+
+function displayAnalyticsFallback() {
+    // Show fallback data when API fails or user not linked
+    const notLinkedMessage = currentLanguage === 'de' ? 
+        'RFID nicht verknüpft - Analytics nicht verfügbar' : 
+        'RFID not linked - Analytics not available';
+    
+    document.getElementById('avgTimeThisWeekDetail').textContent = '--:--';
+    document.getElementById('avgTimeLastWeek').textContent = '--:--';
+    document.getElementById('improvementDetail').textContent = '+0.0%';
+    document.getElementById('runsToday').textContent = '0 Läufe';
+    document.getElementById('runsThisWeekDetail').textContent = '0 Läufe';
+    document.getElementById('avgRunsPerDay').textContent = '0.0';
+    document.getElementById('locationPerformance').innerHTML = `<p style="color: #8892b0; text-align: center; padding: 2rem;">${notLinkedMessage}</p>`;
+    document.getElementById('runsThisMonth').textContent = '0 Läufe';
+    document.getElementById('runsLastMonth').textContent = '0 Läufe';
+    document.getElementById('bestTimeThisMonth').textContent = '--:--';
+}
+
+function displayStatisticsFallback() {
+    // Show fallback data when API fails or user not linked
+    const notLinkedMessage = currentLanguage === 'de' ? 
+        'RFID nicht verknüpft - Statistiken nicht verfügbar' : 
+        'RFID not linked - Statistics not available';
+    
+    document.getElementById('personalRecords').innerHTML = `<p style="color: #8892b0; text-align: center; padding: 2rem;">${notLinkedMessage}</p>`;
+    document.getElementById('averageTime').textContent = '--:--';
+    document.getElementById('timeDeviation').textContent = '--:--';
+    document.getElementById('consistencyScore').textContent = '0%';
+    document.getElementById('rankingStats').innerHTML = `<p style="color: #8892b0; text-align: center; padding: 2rem;">${notLinkedMessage}</p>`;
+    document.getElementById('totalRunsStats').textContent = '0';
+    document.getElementById('activeDays').textContent = '0';
+    document.getElementById('locationsVisited').textContent = '0';
+}
+
+// Get achievement condition value for progress display
+function getAchievementConditionValue(achievementName) {
+    const conditionMap = {
+        'Erste Schritte': 1,
+        'Durchhalter': 3,
+        'Fleißig': 5,
+        'Besessen': 10,
+        'Regelmäßig': 5,
+        'Stammgast': 10,
+        'Treue': 20,
+        'Veteran': 50,
+        'Fortschritt': 5,
+        'Durchbruch': 10,
+        'Transformation': 15,
+        'Perfektionist': 20
+    };
+    return conditionMap[achievementName] || null;
+}
+
+// Show achievement category
+function showAchievementCategory(category) {
+    currentAchievementCategory = category;
+
+    // Update active tab
+    document.querySelectorAll('.category-tab').forEach(tab => {
+        tab.classList.remove('active');
+    });
+    document.querySelector(`[data-category="${category}"]`).classList.add('active');
+
+    // Display filtered achievements
+    displayAchievements();
+}
+
+// Show achievement details (placeholder for future modal)
+function showAchievementDetails(achievementId) {
+    const achievement = playerAchievements.find(a => a.id === achievementId);
+    if (achievement) {
+        console.log('Achievement details:', achievement);
+        // TODO: Implement achievement details modal
+    }
+}
+
+// Show achievements not available state
+function showAchievementsNotAvailable() {
+    document.getElementById('achievementsLoading').style.display = 'none';
+    document.getElementById('achievementStats').style.display = 'none';
+    document.getElementById('achievementCategories').style.display = 'none';
+    document.getElementById('achievementsNotAvailable').style.display = 'block';
+
+    // Update the text content for the not available state
+    const notAvailableTitle = document.querySelector('#achievementsNotAvailable h3');
+    const notAvailableDescription = document.querySelector('#achievementsNotAvailable p');
+    const notAvailableButton = document.querySelector('#achievementsNotAvailable button');
+
+    if (notAvailableTitle) {
+        notAvailableTitle.textContent = currentLanguage === 'de' ?
+            'Achievements noch nicht verfügbar' :
+            'Achievements not available yet';
+    }
+
+    if (notAvailableDescription) {
+        notAvailableDescription.textContent = currentLanguage === 'de' ?
+            'Um Achievements zu sammeln, musst du zuerst deine RFID-Karte mit deinem Account verknüpfen und einige Läufe absolvieren.' :
+            'To collect achievements, you must first link your RFID card with your account and complete some runs.';
+    }
+
+    if (notAvailableButton) {
+        notAvailableButton.textContent = currentLanguage === 'de' ?
+            '🏷️ RFID jetzt verknüpfen' :
+            '🏷️ Link RFID now';
+    }
+
+    // Update the "So funktioniert's" title
+    const howItWorksTitle = document.querySelector('#achievementsNotAvailable h4');
+    if (howItWorksTitle) {
+        howItWorksTitle.textContent = currentLanguage === 'de' ?
+            'So funktioniert\'s:' :
+            'How it works:';
+    }
+
+    // Update the steps
+    const notAvailableSteps = document.querySelectorAll('#achievementsNotAvailable li');
+    if (notAvailableSteps.length >= 3) {
+        notAvailableSteps[0].textContent = currentLanguage === 'de' ?
+            'Klicke auf "RFID jetzt verknüpfen"' :
+            'Click on "Link RFID now"';
+        notAvailableSteps[1].textContent = currentLanguage === 'de' ?
+            'Scanne den QR-Code auf deiner RFID-Karte' :
+            'Scan the QR code on your RFID card';
+        notAvailableSteps[2].textContent = currentLanguage === 'de' ?
+            'Fertig! Deine Zeiten werden automatisch hier angezeigt' :
+            'Done! Your times will be displayed here automatically';
+    }
+}
+
+// Check achievements for current player
+async function checkPlayerAchievements() {
+    if (!currentPlayerId || currentPlayerId === 'undefined' || currentPlayerId === 'null') return;
+
+    try {
+        const response = await fetch(`/api/achievements/check/${currentPlayerId}?t=${Date.now()}`, {
+            method: 'POST'
+        });
+
+        if (response.ok) {
+            const result = await response.json();
+            if (result.data.count > 0) {
+                // Show notification for new achievements
+                showAchievementNotification(result.data.new_achievements);
+                // Reload achievements
+                await loadPlayerAchievements();
+            }
+        }
+    } catch (error) {
+        console.error('Error checking achievements:', error);
+    }
+}
+
+// Show achievement notification
+function showAchievementNotification(newAchievements) {
+    // Create notification element
+    const notification = document.createElement('div');
+    notification.className = 'achievement-notification';
+
+    const titleText = currentLanguage === 'de' ? 'Neue Achievements erreicht!' : 'New Achievements Unlocked!';
+    const descriptionText = currentLanguage === 'de' ?
+        `Du hast ${newAchievements.length} neue Achievement${newAchievements.length > 1 ? 's' : ''} erhalten!` :
+        `You have received ${newAchievements.length} new achievement${newAchievements.length > 1 ? 's' : ''}!`;
+
+    notification.innerHTML = `
+        <div class="notification-content">
+            <div class="notification-icon">🏆</div>
+            <div class="notification-text">
+                <h4>${titleText}</h4>
+                <p>${descriptionText}</p>
+            </div>
+            <button class="notification-close" onclick="this.parentElement.parentElement.remove()">×</button>
+        </div>
+    `;
+
+    // Add to page
+    document.body.appendChild(notification);
+
+    // Auto-remove after 5 seconds
+    setTimeout(() => {
+        if (notification.parentElement) {
+            notification.remove();
+        }
+    }, 5000);
+}
+
+// Initialize achievements when player is loaded
+function initializeAchievements(playerId) {
+    if (playerId && playerId !== 'undefined' && playerId !== 'null') {
+        currentPlayerId = playerId;
+        loadPlayerAchievements();
+    } else {
+        console.warn('Invalid player ID provided to initializeAchievements:', playerId);
+        currentPlayerId = null;
+    }
+}
+
+// Convert VAPID key from base64url to Uint8Array
+function urlBase64ToUint8Array(base64String) {
+    const padding = '='.repeat((4 - base64String.length % 4) % 4);
+    const base64 = (base64String + padding)
+        .replace(/\-/g, '+')
+        .replace(/_/g, '/');
+    
+    const rawData = window.atob(base64);
+    const outputArray = new Uint8Array(rawData.length);
+    
+    for (let i = 0; i < rawData.length; ++i) {
+        outputArray[i] = rawData.charCodeAt(i);
+    }
+    return outputArray;
+}
+
+// Push notifications are now handled in dashboard.html
+// This function has been moved to the HTML file for better integration
+
+// Web Notification Functions
+function showWebNotification(title, message, icon = '🏆') {
+    if ('Notification' in window && Notification.permission === 'granted') {
+        // Log notification details to console
+        console.log('🔔 Web Notification sent:', {
+            title: title,
+            message: message,
+            icon: icon,
+            playerId: currentPlayerId || 'unknown',
+            pushPlayerId: localStorage.getItem('pushPlayerId') || 'unknown',
+            timestamp: new Date().toISOString()
+        });
+        
+        const notification = new Notification(title, {
+            body: message,
+            icon: '/pictures/icon-192.png',
+            badge: '/pictures/icon-192.png',
+            tag: 'ninjacross-achievement',
+            requireInteraction: true
+        });
+
+        // Auto-close after 10 seconds
+        setTimeout(() => {
+            notification.close();
+        }, 10000);
+
+        // Handle click
+        notification.onclick = function () {
+            window.focus();
+            notification.close();
+        };
+    }
+}
+
+// Track which notifications have been sent today
+let notificationsSentToday = {
+    daily: false,
+    weekly: false,
+    monthly: false
+};
+
+// Check for best time achievements and show notifications
+async function checkBestTimeNotifications() {
+    try {
+        // Check if push notifications are enabled
+        const pushPlayerId = localStorage.getItem('pushPlayerId');
+        if (!pushPlayerId) {
+            
+            return;
+        }
+
+        const response = await fetch('/api/v1/public/best-times');
+        const result = await response.json();
+
+        if (result.success && result.data) {
+            const { daily, weekly, monthly } = result.data;
+
+            // Check if current player has best times
+            if (currentPlayerId && currentPlayerId !== 'undefined' && currentPlayerId !== 'null') {
+                const now = new Date();
+                const isEvening = now.getHours() >= 19;
+                
+                // Check daily best time (only in the evening, only once per day)
+                if (daily && daily.player_id === currentPlayerId && isEvening) {
+                    // Check if notification was already sent today
+                    const dailyCheck = await fetch(`/api/v1/public/notification-sent/${currentPlayerId}/daily_best`);
+                    const dailyResult = await dailyCheck.json();
+                    
+                    if (!dailyResult.wasSent) {
+                        const title = currentLanguage === 'de' ? '🏆 Tageskönig!' : '🏆 Daily King!';
+                        const message = currentLanguage === 'de' ?
+                            `Glückwunsch! Du hast die beste Zeit des Tages mit ${daily.best_time} erreicht!` :
+                            `Congratulations! You achieved the best time of the day with ${daily.best_time}!`;
+                        showWebNotification(title, message, '👑');
+                        
+                        // Mark as sent in database
+                        await fetch('/api/v1/public/notification-sent', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({
+                                playerId: currentPlayerId,
+                                notificationType: 'daily_best'
+                            })
+                        });
+                        
+                    }
+                }
+
+                // Check weekly best time (only on Sunday evening, only once per week)
+                if (weekly && weekly.player_id === currentPlayerId) {
+                    const isSunday = now.getDay() === 0; // 0 = Sunday
+                    
+                    if (isSunday && isEvening) {
+                        // Check if notification was already sent this week
+                        const weeklyCheck = await fetch(`/api/v1/public/notification-sent/${currentPlayerId}/weekly_best`);
+                        const weeklyResult = await weeklyCheck.json();
+                        
+                        if (!weeklyResult.wasSent) {
+                            const title = currentLanguage === 'de' ? '🏆 Wochenchampion!' : '🏆 Weekly Champion!';
+                            const message = currentLanguage === 'de' ?
+                                `Fantastisch! Du bist der Wochenchampion mit ${weekly.best_time}!` :
+                                `Fantastic! You are the weekly champion with ${weekly.best_time}!`;
+                            showWebNotification(title, message, '🏆');
+                            
+                            // Mark as sent in database
+                            await fetch('/api/v1/public/notification-sent', {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify({
+                                    playerId: currentPlayerId,
+                                    notificationType: 'weekly_best'
+                                })
+                            });
+                            
+                        }
+                    }
+                }
+
+                // Check monthly best time (only on last evening of month at 19:00, only once per month)
+                if (monthly && monthly.player_id === currentPlayerId) {
+                    const lastDayOfMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0);
+                    const isLastDayOfMonth = now.getDate() === lastDayOfMonth.getDate();
+                    
+                    // Only show monthly notification on last day of month at 19:00 or later
+                    if (isLastDayOfMonth && isEvening) {
+                        // Check if notification was already sent this month
+                        const monthlyCheck = await fetch(`/api/v1/public/notification-sent/${currentPlayerId}/monthly_best`);
+                        const monthlyResult = await monthlyCheck.json();
+                        
+                        if (!monthlyResult.wasSent) {
+                            const title = currentLanguage === 'de' ? '🏆 Monatsmeister!' : '🏆 Monthly Master!';
+                            const message = currentLanguage === 'de' ?
+                                `Unglaublich! Du bist der Monatsmeister mit ${monthly.best_time}!` :
+                                `Incredible! You are the monthly master with ${monthly.best_time}!`;
+                            showWebNotification(title, message, '🥇');
+                            
+                            // Mark as sent in database
+                            await fetch('/api/v1/public/notification-sent', {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify({
+                                    playerId: currentPlayerId,
+                                    notificationType: 'monthly_best'
+                                })
+                            });
+                            
+                        }
+                    }
+                }
+            }
+        }
+    } catch (error) {
+        console.error('Error checking best time notifications:', error);
+    }
+}
+
+// Check for new achievements and show notifications
+async function checkAchievementNotifications() {
+    try {
+        
+        // Check if push notifications are enabled
+        const pushPlayerId = localStorage.getItem('pushPlayerId');
+        if (!pushPlayerId) {
+            return;
+        }
+        
+        
+
+        // Use pushPlayerId for notifications instead of currentPlayerId
+        if (!pushPlayerId || pushPlayerId === 'undefined' || pushPlayerId === 'null') return;
+
+        const response = await fetch(`/api/achievements/player/${pushPlayerId}?t=${Date.now()}`);
+        const result = await response.json();
+
+        if (result.success && result.data) {
+                        
+            const newAchievements = result.data.filter(achievement => {
+                // Only check completed achievements
+                if (!achievement.is_completed) {
+                    return false;
+                }
+                
+                // Check if achievement was earned in the last 10 minutes (extended window)
+                const earnedAt = achievement.earned_at ? new Date(achievement.earned_at) : null;
+                const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000);
+                
+                // If no earned_at date, check if it was completed recently by checking completion_count
+                if (!earnedAt) {
+                    
+                    
+                    // For achievements without earned_at, assume they are new if completion_count is 1
+                    // This is a fallback for recently completed achievements
+                    return achievement.completion_count === 1;
+                }
+                
+                const isNew = earnedAt > tenMinutesAgo;
+                
+                
+                
+                return isNew;
+            });
+            
+            
+
+            if (newAchievements.length > 0) {
+                for (const achievement of newAchievements) {
+                    // Check if notification was already sent for this achievement
+                    const achievementId = achievement.id || achievement.achievement_id;
+                    const locationId = achievement.location_id || '';
+                    
+                    if (!achievementId) {
+                        console.warn('Achievement ID is missing for achievement:', achievement);
+                        continue;
+                    }
+                    
+                    const achievementCheck = await fetch(`/api/v1/public/notification-sent/${pushPlayerId}/achievement?achievementId=${achievementId}&locationId=${locationId}`);
+                    const achievementResult = await achievementCheck.json();
+                    
+                    if (!achievementResult.wasSent) {
+                        const translatedAchievement = translateAchievement(achievement);
+                        showWebNotification(
+                            `🏆 ${translatedAchievement.name}`,
+                            translatedAchievement.description,
+                            achievement.icon || '🏆'
+                        );
+                        
+                        // Mark as sent in database
+                        await fetch('/api/v1/public/notification-sent', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({
+                                playerId: pushPlayerId,
+                                notificationType: 'achievement',
+                                achievementId: achievementId,
+                                locationId: locationId || null
+                            })
+                        });
+                        
+                    }
+                }
+            }
+        }
+    } catch (error) {
+        console.error('Error checking achievement notifications:', error);
+    }
+}
+
+
+// Periodic check for notifications (every 30 seconds)
+setInterval(() => {
+    checkBestTimeNotifications();
+    checkAchievementNotifications();
+}, 30000);
+
+// Settings Functions
+function showSettings() {
+    const modal = document.getElementById('settingsModal');
+    if (modal) {
+        modal.style.display = 'block';
+        loadSettings();
+    }
+}
+
+async function loadSettings() {
+    try {
+        if (!currentUser || !currentUser.id) {
+            console.error('No user ID available');
+            return;
+        }
+
+        // Load current player settings using user ID
+        const response = await fetch(`/api/v1/public/user-player/${currentUser.id}`);
+        const result = await response.json();
+
+        if (result.success && result.data) {
+            const showInLeaderboard = result.data.show_in_leaderboard || false;
+            document.getElementById('showInLeaderboard').checked = showInLeaderboard;
+            console.log('Loaded settings - showInLeaderboard:', showInLeaderboard);
+        } else {
+            console.error('Failed to load player settings:', result.message);
+            // Set default to false if loading fails
+            document.getElementById('showInLeaderboard').checked = false;
+        }
+    } catch (error) {
+        console.error('Error loading settings:', error);
+        // Set default to false if loading fails
+        document.getElementById('showInLeaderboard').checked = false;
+    }
+}
+
+function updateLeaderboardSetting() {
+    const checkbox = document.getElementById('showInLeaderboard');
+    console.log('Leaderboard setting changed:', checkbox.checked);
+}
+
+async function saveSettings() {
+    try {
+        if (!currentPlayerId || currentPlayerId === 'undefined' || currentPlayerId === 'null') {
+            console.error('No player ID available');
+            return;
+        }
+
+        const showInLeaderboard = document.getElementById('showInLeaderboard').checked;
+
+        // Update player settings using public endpoint (no API key needed)
+        const response = await fetch(`/api/v1/public/update-player-settings`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                player_id: currentPlayerId,
+                show_in_leaderboard: showInLeaderboard
+            })
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+            const successMsg = currentLanguage === 'de' ?
+                'Einstellungen erfolgreich gespeichert!' :
+                'Settings saved successfully!';
+            showNotification(successMsg, 'success');
+            closeModal('settingsModal');
+        } else {
+            const errorMsg = currentLanguage === 'de' ?
+                'Fehler beim Speichern der Einstellungen: ' + result.message :
+                'Error saving settings: ' + result.message;
+            showNotification(errorMsg, 'error');
+        }
+    } catch (error) {
+        console.error('Error saving settings:', error);
+        const errorMsg = currentLanguage === 'de' ?
+            'Fehler beim Speichern der Einstellungen' :
+            'Error saving settings';
+        showNotification(errorMsg, 'error');
+    }
+}
+
+function showNotification(message, type = 'info') {
+    // Create notification element
+    const notification = document.createElement('div');
+    notification.className = `notification notification-${type}`;
+    notification.style.cssText = `
+        position: fixed;
+        top: 20px;
+        right: 20px;
+        background: ${type === 'success' ? '#10b981' : type === 'error' ? '#ef4444' : '#3b82f6'};
+        color: white;
+        padding: 1rem 1.5rem;
+        border-radius: 0.5rem;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        z-index: 10000;
+        max-width: 300px;
+        font-weight: 500;
+    `;
+    notification.textContent = message;
+
+    document.body.appendChild(notification);
+
+    // Remove notification after 3 seconds
+    setTimeout(() => {
+        if (notification.parentNode) {
+            notification.parentNode.removeChild(notification);
+        }
+    }, 3000);
+}
+
+document.addEventListener('DOMContentLoaded', function () {
+    // Add cookie settings button functionality
+    const cookieSettingsBtn = document.getElementById('cookie-settings-footer');
+    if (cookieSettingsBtn) {
+        cookieSettingsBtn.addEventListener('click', function () {
+            if (window.cookieConsent) {
+                window.cookieConsent.resetConsent();
+            }
+        });
+    }
+    
+    // Check push notification status on dashboard load
+    if (typeof checkPushStatus === 'function') {
+        checkPushStatus();
+    }
+});
diff --git a/public/js/generator.js b/public/js/generator.js
new file mode 100644
index 0000000..85c4032
--- /dev/null
+++ b/public/js/generator.js
@@ -0,0 +1,573 @@
+// Toggle Token-Felder basierend auf Lizenzstufe
+function toggleTokenFields() {
+    const tierInput = document.getElementById("tier");
+    const dbConfig = document.getElementById("dbConfig");
+    const tier = parseInt(tierInput.value);
+
+    if (tier >= 3 && !isNaN(tier)) {
+        dbConfig.innerHTML = `
+            <h3>🗄️ Token-Informationen (für Stufe 3+)</h3>
+            <div class="form-group">
+                <label for="description">Token Beschreibung</label>
+                <textarea id="description" placeholder="z.B. API-Zugang für Standort München"></textarea>
+            </div>
+            <div class="form-group">
+                <label for="standorte">Standorte</label>
+                <input type="text" id="standorte" placeholder="z.B. München, Berlin">
+            </div>
+            
+                                         <!-- Neue Standortsuche-Sektion -->
+                     <div class="form-group">
+                         <label for="locationSearch">Standort suchen & auf Karte anzeigen</label>
+                         <div class="location-search-container">
+                             <input type="text" id="locationSearch" placeholder="z.B. München, Marienplatz">
+                             <button onclick="searchLocation(this)" style="padding: 15px 20px; background: #4caf50; color: white; border: none; border-radius: 12px; cursor: pointer; font-weight: 500; transition: all 0.3s ease;">🔍 Suchen</button>
+                         </div>
+                     </div>
+                    
+                                         <!-- Koordinaten-Anzeige -->
+                     <div id="coordinates" class="coordinates-display" style="display: none;">
+                         <div style="background: #f0f8ff; border: 2px solid #4caf50; border-radius: 8px; padding: 15px; margin-top: 15px;">
+                             <h4 style="margin: 0 0 10px 0; color: #2e7d32;">📍 Gefundene Koordinaten:</h4>
+                             <div style="display: flex; gap: 20px; flex-wrap: wrap;">
+                                 <div>
+                                     <strong>Breitengrad (LAT):</strong> 
+                                     <span id="latitude" style="font-family: monospace; color: #1565c0;"></span>
+                                 </div>
+                                 <div>
+                                     <strong>Längengrad (LON):</strong> 
+                                     <span id="longitude" style="font-family: monospace; color: #1565c0;"></span>
+                                 </div>
+                             </div>
+                             <div style="margin-top: 15px; text-align: center;">
+                                 <div style="font-size: 0.85em; color: #666; margin-bottom: 10px;">
+                                     💡 Der Standort wird automatisch beim Generieren der Lizenz gespeichert
+                                 </div>
+                                 <button id="saveLocationBtn" onclick="saveLocationToDatabase()" style="padding: 12px 24px; background: #2196f3; color: white; border: none; border-radius: 8px; cursor: pointer; font-weight: 500; transition: all 0.3s ease;">
+                                     💾 Standort manuell speichern
+                                 </button>
+                             </div>
+                         </div>
+                     </div>
+                    
+                    <!-- Karten-Container -->
+                    <div id="mapContainer" class="map-container" style="display: none; margin-top: 20px;">
+                        <h4 style="margin: 0 0 15px 0; color: #333;">🗺️ Standort auf der Karte:</h4>
+                        <div id="mapFrame" style="width: 100%; height: 300px; border: 2px solid #ddd; border-radius: 12px; overflow: hidden;"></div>
+                    </div>
+                    <div class="info-text" style="margin-top: 10px; font-size: 0.8em;">
+                        📝 Standorte werden in der lokalen PostgreSQL-Datenbank gespeichert
+                    </div>
+                `;
+        dbConfig.classList.add("show");
+    } else {
+        dbConfig.classList.remove("show");
+        setTimeout(() => {
+            if (!dbConfig.classList.contains("show")) {
+                dbConfig.innerHTML = "";
+            }
+        }, 400);
+    }
+}
+
+const secret = "542ff224606c61fb3024e22f76ef9ac8";
+
+function isValidMac(mac) {
+    const pattern = /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$|^[0-9A-Fa-f]{12}$/;
+    return pattern.test(mac);
+}
+
+function showMessage(elementId, message, isError = false) {
+    const messageDiv = document.getElementById(elementId);
+    messageDiv.textContent = message;
+    messageDiv.classList.add("show");
+    setTimeout(() => {
+        messageDiv.classList.remove("show");
+    }, 4000);
+}
+
+function showError(message) {
+    showMessage("error", message, true);
+}
+
+function showSuccess(message) {
+    showMessage("success", message, false);
+}
+
+function setLoading(isLoading) {
+    const btnText = document.getElementById("btn-text");
+    const btn = document.querySelector(".generate-btn");
+
+    if (isLoading) {
+        btnText.innerHTML = '<span class="loading"></span>Generiere...';
+        btn.disabled = true;
+        btn.style.opacity = '0.7';
+    } else {
+        btnText.textContent = 'Lizenz generieren';
+        btn.disabled = false;
+        btn.style.opacity = '1';
+    }
+}
+
+async function saveToDatabase(token, tier) {
+    const description = document.getElementById("description").value.trim();
+    const standorte = document.getElementById("standorte").value.trim();
+
+    try {
+        const response = await fetch('/api/v1/web/save-token', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                token: token,
+                description: description || `API-Token Stufe ${tier}`,
+                standorte: standorte
+            })
+        });
+
+        if (!response.ok) {
+            const errorData = await response.json();
+            throw new Error(errorData.message || 'Fehler beim Speichern in der Datenbank');
+        }
+
+        const result = await response.json();
+        return result;
+    } catch (error) {
+        // Fallback: Zeige dem Benutzer den SQL-Befehl an, den er manuell ausführen kann
+        const sql = `INSERT INTO api_tokens (token, description, standorte) VALUES ('${token}', '${description || `API-Token Stufe ${tier}`}', '${standorte}');`;
+
+        throw new Error(`Automatisches Speichern fehlgeschlagen. Server nicht erreichbar.\n\nFühren Sie folgenden SQL-Befehl manuell aus:\n${sql}`);
+    }
+}
+
+async function generateLicense() {
+    const macInput = document.getElementById("mac").value.trim();
+    const tierInput = document.getElementById("tier").value.trim();
+    const resultDiv = document.getElementById("result");
+    const licenseOutput = document.getElementById("license-output");
+    const errorDiv = document.getElementById("error");
+    const successDiv = document.getElementById("success");
+
+    // Reset states
+    resultDiv.classList.remove("show");
+    errorDiv.classList.remove("show");
+    successDiv.classList.remove("show");
+    setLoading(true);
+
+    // Simulate slight delay for better UX
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    try {
+        if (!isValidMac(macInput)) {
+            throw new Error("Ungültige MAC-Adresse. Bitte verwenden Sie das Format 00:1A:2B:3C:4D:5E");
+        }
+
+        const mac = macInput.replace(/[:-]/g, "").toUpperCase();
+        const tier = parseInt(tierInput);
+
+        if (isNaN(tier) || tier < 1 || tier > 4) {
+            throw new Error("Lizenzstufe muss eine Zahl zwischen 1 und 4 sein.");
+        }
+
+        // Standort automatisch speichern, falls vorhanden
+        let locationSaved = false;
+        const locationName = document.getElementById('locationSearch')?.value?.trim();
+        const latitude = document.getElementById('latitude')?.textContent;
+        const longitude = document.getElementById('longitude')?.textContent;
+
+        if (locationName && latitude && longitude && tier >= 3) {
+            try {
+                await saveLocationToDatabase();
+                locationSaved = true;
+            } catch (locationError) {
+                console.warn('Standort konnte nicht gespeichert werden:', locationError);
+                // Fahre trotzdem mit der Lizenzgenerierung fort
+            }
+        }
+
+        const data = `${mac}:${tier}`;
+        const enc = new TextEncoder();
+        const key = await crypto.subtle.importKey(
+            "raw",
+            enc.encode(secret),
+            { name: "HMAC", hash: "SHA-256" },
+            false,
+            ["sign"]
+        );
+        const signature = await crypto.subtle.sign("HMAC", key, enc.encode(data));
+        const hex = Array.from(new Uint8Array(signature))
+            .map(b => b.toString(16).padStart(2, "0"))
+            .join("")
+            .toUpperCase();
+
+        licenseOutput.textContent = hex;
+        resultDiv.classList.add("show");
+
+        // Reset copy button
+        const copyBtn = document.getElementById("copyButton");
+        copyBtn.textContent = "📋 In Zwischenablage kopieren";
+        copyBtn.classList.remove("copied");
+
+        // Bei Stufe 3+ in Datenbank speichern
+        if (tier >= 3) {
+            try {
+                await saveToDatabase(hex, tier);
+                let successMessage = `✅ Lizenzschlüssel generiert und als API-Token gespeichert!`;
+                if (locationSaved) {
+                    successMessage += ` Standort wurde ebenfalls gespeichert.`;
+                }
+                showSuccess(successMessage);
+            } catch (dbError) {
+                showError(`⚠️ Lizenz generiert, aber Datenbank-Fehler: ${dbError.message}`);
+            }
+        } else {
+            let successMessage = `✅ Lizenzschlüssel erfolgreich generiert!`;
+            if (locationSaved) {
+                successMessage += ` Standort wurde in der Datenbank gespeichert.`;
+            }
+            showSuccess(successMessage);
+        }
+
+    } catch (error) {
+        showError(error.message);
+    } finally {
+        setLoading(false);
+    }
+}
+
+async function copyToClipboard() {
+    const licenseOutput = document.getElementById("license-output");
+    const copyBtn = document.getElementById("copyButton");
+
+    try {
+        await navigator.clipboard.writeText(licenseOutput.textContent);
+        copyBtn.textContent = "✅ Kopiert!";
+        copyBtn.classList.add("copied");
+
+        setTimeout(() => {
+            copyBtn.textContent = "📋 In Zwischenablage kopieren";
+            copyBtn.classList.remove("copied");
+        }, 2000);
+    } catch (err) {
+        // Fallback for older browsers
+        const textArea = document.createElement("textarea");
+        textArea.value = licenseOutput.textContent;
+        document.body.appendChild(textArea);
+        textArea.select();
+        document.execCommand('copy');
+        document.body.removeChild(textArea);
+
+        copyBtn.textContent = "✅ Kopiert!";
+        copyBtn.classList.add("copied");
+
+        setTimeout(() => {
+            copyBtn.textContent = "📋 In Zwischenablage kopieren";
+            copyBtn.classList.remove("copied");
+        }, 2000);
+    }
+}
+
+// Enter key support
+document.addEventListener('keypress', function (e) {
+    if (e.key === 'Enter') {
+        generateLicense();
+    }
+});
+
+// Input formatting for MAC address
+document.getElementById('mac').addEventListener('input', function (e) {
+    let value = e.target.value.replace(/[^0-9A-Fa-f]/g, '');
+    if (value.length > 12) value = value.substr(0, 12);
+
+    // Add colons every 2 characters
+    value = value.replace(/(.{2})/g, '$1:').replace(/:$/, '');
+    e.target.value = value;
+});
+
+// Input event listener für Lizenzstufe
+document.getElementById('tier').addEventListener('input', toggleTokenFields);
+
+// Standortsuche-Funktionalität
+async function searchLocation(buttonElement) {
+    const locationInput = document.getElementById('locationSearch').value.trim();
+    const coordinatesDiv = document.getElementById('coordinates');
+    const mapContainer = document.getElementById('mapContainer');
+    const latitudeSpan = document.getElementById('latitude');
+    const longitudeSpan = document.getElementById('longitude');
+    const mapFrame = document.getElementById('mapFrame');
+
+    if (!locationInput) {
+        showError('Bitte geben Sie einen Standort ein.');
+        return;
+    }
+
+    let originalText = '';
+    let searchBtn = null;
+
+    try {
+        // Zeige Ladeanimation
+        searchBtn = buttonElement || document.querySelector('button[onclick*="searchLocation"]');
+        if (searchBtn) {
+            originalText = searchBtn.innerHTML;
+            searchBtn.innerHTML = '<span class="loading"></span>Suche...';
+            searchBtn.disabled = true;
+        }
+
+        // API-Abfrage an Nominatim (OpenStreetMap)
+        const response = await fetch(`https://nominatim.openstreetmap.org/search?format=json&q=${encodeURIComponent(locationInput)}&limit=1`);
+
+        if (!response.ok) {
+            throw new Error('Fehler bei der API-Abfrage');
+        }
+
+        const data = await response.json();
+
+        if (data.length === 0) {
+            throw new Error('Standort nicht gefunden. Bitte versuchen Sie eine andere Beschreibung.');
+        }
+
+        const location = data[0];
+        const lat = parseFloat(location.lat);
+        const lon = parseFloat(location.lon);
+
+        // Der Name wird vom User bestimmt - nur Koordinaten aus der API verwenden
+        // Kein verstecktes Feld nötig, da der User den Namen selbst eingibt
+
+        // Koordinaten anzeigen
+        updateCoordinates(lat, lon);
+        coordinatesDiv.style.display = 'block';
+
+        // Interaktive Karte erstellen
+        createInteractiveMap(lat, lon);
+        mapContainer.style.display = 'block';
+
+        // Erfolgsmeldung
+        showSuccess(`✅ Koordinaten für "${locationInput}" erfolgreich gefunden! Klicken Sie auf die Karte, um den Pin zu verschieben.`);
+
+    } catch (error) {
+        showError(`Fehler bei der Standortsuche: ${error.message}`);
+        coordinatesDiv.style.display = 'none';
+        mapContainer.style.display = 'none';
+    } finally {
+        // Button zurücksetzen
+        if (searchBtn && originalText) {
+            searchBtn.innerHTML = originalText;
+            searchBtn.disabled = false;
+        }
+    }
+}
+
+// Koordinaten aktualisieren
+function updateCoordinates(lat, lon) {
+    const latitudeSpan = document.getElementById('latitude');
+    const longitudeSpan = document.getElementById('longitude');
+
+    if (latitudeSpan && longitudeSpan) {
+        latitudeSpan.textContent = lat.toFixed(6);
+        longitudeSpan.textContent = lon.toFixed(6);
+    }
+}
+
+// Interaktive Karte erstellen
+function createInteractiveMap(initialLat, initialLon) {
+    const mapFrame = document.getElementById('mapFrame');
+
+    // Verwende Leaflet.js für interaktive Karte
+    const mapHtml = `
+                <div id="interactiveMap" style="width: 100%; height: 100%; position: relative;">
+                    <div id="map" style="width: 100%; height: 100%; border-radius: 10px;"></div>
+                    <div style="position: absolute; top: 10px; right: 10px; background: white; padding: 8px; border-radius: 6px; box-shadow: 0 2px 8px rgba(0,0,0,0.2); font-size: 12px; color: #666;">
+                        📍 Klicken Sie auf die Karte, um den Pin zu verschieben
+                    </div>
+                </div>
+            `;
+
+    mapFrame.innerHTML = mapHtml;
+
+    // Leaflet.js laden und Karte initialisieren
+    loadLeafletAndCreateMap(initialLat, initialLon);
+}
+
+// Leaflet.js laden und Karte erstellen
+function loadLeafletAndCreateMap(initialLat, initialLon) {
+    // Prüfe ob Leaflet bereits geladen ist
+    if (typeof L !== 'undefined') {
+        createMap(initialLat, initialLon);
+        return;
+    }
+
+    // Leaflet CSS laden
+    const leafletCSS = document.createElement('link');
+    leafletCSS.rel = 'stylesheet';
+    leafletCSS.href = 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.css';
+    document.head.appendChild(leafletCSS);
+
+    // Leaflet JavaScript laden
+    const leafletScript = document.createElement('script');
+    leafletScript.src = 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.js';
+    leafletScript.onload = () => createMap(initialLat, initialLon);
+    document.head.appendChild(leafletScript);
+}
+
+// Karte mit Leaflet erstellen
+function createMap(initialLat, initialLon) {
+    try {
+        const map = L.map('map').setView([initialLat, initialLon], 15);
+
+        // OpenStreetMap Tile Layer
+        L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+            attribution: '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'
+        }).addTo(map);
+
+        // Marker erstellen
+        const marker = L.marker([initialLat, initialLon], {
+            draggable: true,
+            title: 'Standort'
+        }).addTo(map);
+
+        // Marker-Drag Event
+        marker.on('dragend', function (event) {
+            const newLat = event.target.getLatLng().lat;
+            const newLon = event.target.getLatLng().lng;
+            updateCoordinates(newLat, newLon);
+            showSuccess(`📍 Pin auf neue Position verschoben: ${newLat.toFixed(6)}, ${newLon.toFixed(6)}`);
+        });
+
+        // Klick-Event auf die Karte
+        map.on('click', function (event) {
+            const newLat = event.latlng.lat;
+            const newLon = event.latlng.lng;
+
+            // Marker auf neue Position setzen
+            marker.setLatLng([newLat, newLon]);
+
+            // Koordinaten aktualisieren
+            updateCoordinates(newLat, newLon);
+
+            // Erfolgsmeldung
+            showSuccess(`📍 Pin auf neue Position gesetzt: ${newLat.toFixed(6)}, ${newLon.toFixed(6)}`);
+        });
+
+        // Zoom-Controls hinzufügen
+        map.zoomControl.setPosition('bottomright');
+
+    } catch (error) {
+        console.error('Fehler beim Erstellen der Karte:', error);
+        // Fallback zu iframe
+        const mapFrame = document.getElementById('mapFrame');
+        const mapUrl = `https://www.openstreetmap.org/export/embed.html?bbox=${initialLon - 0.01},${initialLat - 0.01},${initialLon + 0.01},${initialLat + 0.01}&layer=mapnik&marker=${initialLat},${initialLon}`;
+        mapFrame.innerHTML = `<iframe src="${mapUrl}" width="100%" height="100%" frameborder="0" scrolling="no" marginheight="0" marginwidth="0" title="Standort auf der Karte"></iframe>`;
+    }
+}
+
+// Standort in Datenbank speichern
+async function saveLocationToDatabase() {
+    const locationName = document.getElementById('standorte').value.trim();
+    const latitude = document.getElementById('latitude').textContent;
+    const longitude = document.getElementById('longitude').textContent;
+    const saveBtn = document.getElementById('saveLocationBtn');
+
+    if (!locationName || !latitude || !longitude) {
+        showError('Bitte suchen Sie zuerst einen Standort.');
+        return;
+    }
+
+    try {
+        // Button-Status ändern
+        const originalText = saveBtn.innerHTML;
+        saveBtn.innerHTML = '<span class="loading"></span>Speichere...';
+        saveBtn.disabled = true;
+
+        // Web-authenticated API für Standortverwaltung aufrufen
+        const response = await fetch('/api/v1/web/create-location', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                name: locationName,
+                lat: parseFloat(latitude),
+                lon: parseFloat(longitude)
+            })
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+            showSuccess(`✅ Standort "${locationName}" erfolgreich in der Datenbank gespeichert!`);
+            saveBtn.innerHTML = '✅ Gespeichert!';
+            saveBtn.style.background = '#4caf50';
+
+            // Button nach 3 Sekunden zurücksetzen
+            setTimeout(() => {
+                saveBtn.innerHTML = originalText;
+                saveBtn.disabled = false;
+                saveBtn.style.background = '#2196f3';
+            }, 3000);
+        } else {
+            throw new Error(result.message || 'Unbekannter Fehler beim Speichern');
+        }
+
+    } catch (error) {
+        console.error('Fehler beim Speichern:', error);
+        showError(`Fehler beim Speichern: ${error.message}`);
+
+        // Button zurücksetzen
+        saveBtn.innerHTML = '💾 Standort in Datenbank speichern';
+        saveBtn.disabled = false;
+    }
+}
+
+// Zurück zum Dashboard
+function goBackToDashboard() {
+    window.location.href = '/admin-dashboard';
+}
+
+// Logout-Funktion
+async function logout() {
+    try {
+        const response = await fetch('/api/v1/public/logout', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            }
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+            window.location.href = '/login';
+        } else {
+            console.error('Fehler beim Abmelden:', result.message);
+            // Trotzdem zur Login-Seite weiterleiten
+            window.location.href = '/login';
+        }
+    } catch (error) {
+        console.error('Fehler beim Abmelden:', error);
+        // Bei Fehler trotzdem zur Login-Seite weiterleiten
+        window.location.href = '/login';
+    }
+}
+
+// Enter-Taste für Standortsuche
+document.addEventListener('DOMContentLoaded', function () {
+    const locationSearch = document.getElementById('locationSearch');
+    if (locationSearch) {
+        locationSearch.addEventListener('keypress', function (e) {
+            if (e.key === 'Enter') {
+                searchLocation();
+            }
+        });
+    }
+
+    // Add cookie settings button functionality
+    const cookieSettingsBtn = document.getElementById('cookie-settings-footer');
+    if (cookieSettingsBtn) {
+        cookieSettingsBtn.addEventListener('click', function () {
+            if (window.cookieConsent) {
+                window.cookieConsent.resetConsent();
+            }
+        });
+    }
+});
diff --git a/public/js/index.js b/public/js/index.js
new file mode 100644
index 0000000..666d925
--- /dev/null
+++ b/public/js/index.js
@@ -0,0 +1,808 @@
+// Supabase configuration
+const SUPABASE_URL = 'https://lfxlplnypzvjrhftaoog.supabase.co';
+const SUPABASE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImxmeGxwbG55cHp2anJoZnRhb29nIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDkyMTQ3NzIsImV4cCI6MjA2NDc5MDc3Mn0.XR4preBqWAQ1rT4PFbpkmRdz57BTwIusBI89fIxDHM8';
+
+// Initialize Supabase client
+const supabase = window.supabase.createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
+
+// Initialize Socket.IO connection
+let socket;
+
+function setupSocketListeners() {
+    if (!socket) return;
+
+    socket.on('connect', () => {
+        console.log('🔌 WebSocket connected');
+    });
+
+    socket.on('disconnect', () => {
+        console.log('🔌 WebSocket disconnected');
+    });
+
+    socket.on('newTime', (data) => {
+        console.log('🏁 New time received:', data);
+        showNotification(data);
+        // Reload data to show the new time
+        loadData();
+    });
+}
+
+function initializeSocket() {
+    if (typeof io !== 'undefined') {
+        socket = io();
+        setupSocketListeners();
+    } else {
+        console.error('Socket.IO library not loaded');
+    }
+}
+
+// Try to initialize immediately, fallback to DOMContentLoaded
+if (typeof io !== 'undefined') {
+    initializeSocket();
+} else {
+    document.addEventListener('DOMContentLoaded', initializeSocket);
+}
+
+// Global variable to store locations with coordinates
+let locationsData = [];
+let lastSelectedLocation = null;
+
+// Cookie Functions (inline implementation)
+function setCookie(name, value, days = 30) {
+    const expires = new Date();
+    expires.setTime(expires.getTime() + (days * 24 * 60 * 60 * 1000));
+    document.cookie = `${name}=${value};expires=${expires.toUTCString()};path=/;SameSite=Lax`;
+}
+
+function getCookie(name) {
+    const nameEQ = name + "=";
+    const ca = document.cookie.split(';');
+    for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
+        while (c.charAt(0) === ' ') c = c.substring(1, c.length);
+        if (c.indexOf(nameEQ) === 0) return c.substring(nameEQ.length, c.length);
+    }
+    return null;
+}
+
+function loadLastSelectedLocation() {
+    try {
+        const cookieValue = getCookie('ninjacross_last_location');
+        if (cookieValue) {
+            const lastLocation = JSON.parse(cookieValue);
+            lastSelectedLocation = lastLocation;
+            console.log('📍 Last selected location loaded:', lastLocation.name);
+            return lastLocation;
+        }
+    } catch (error) {
+        console.error('Error loading last location:', error);
+    }
+    return null;
+}
+
+function saveLocationSelection(locationId, locationName) {
+    try {
+        // Remove emoji from location name for storage
+        const cleanName = locationName.replace(/^📍\s*/, '');
+        const locationData = {
+            id: locationId,
+            name: cleanName,
+            timestamp: new Date().toISOString()
+        };
+
+        setCookie('ninjacross_last_location', JSON.stringify(locationData), 90);
+        lastSelectedLocation = { id: locationId, name: cleanName };
+        console.log('💾 Location saved to cookie:', cleanName);
+    } catch (error) {
+        console.error('Error saving location:', error);
+    }
+}
+
+// WebSocket Event Handlers are now in setupSocketListeners() function
+
+// Notification Functions
+function showNotification(timeData) {
+    const notificationBubble = document.getElementById('notificationBubble');
+    const notificationTitle = document.getElementById('notificationTitle');
+    const notificationSubtitle = document.getElementById('notificationSubtitle');
+
+    // Format the time data
+    const playerName = timeData.player_name || (currentLanguage === 'de' ? 'Unbekannter Spieler' : 'Unknown Player');
+    const locationName = timeData.location_name || (currentLanguage === 'de' ? 'Unbekannter Standort' : 'Unknown Location');
+    const timeString = timeData.recorded_time || '--:--';
+
+    // Update notification content
+    const newTimeText = currentLanguage === 'de' ? 'Neue Zeit von' : 'New time from';
+    notificationTitle.textContent = `🏁 ${newTimeText} ${playerName}!`;
+    notificationSubtitle.textContent = `${timeString} • ${locationName}`;
+
+    // Ensure notification is above sticky header
+    notificationBubble.style.zIndex = '100000';
+
+    // Check if we're on mobile and adjust position
+    if (window.innerWidth <= 768) {
+        notificationBubble.style.top = '5rem'; // Below sticky header on mobile
+    } else {
+        notificationBubble.style.top = '2rem'; // Normal position on desktop
+    }
+
+    // Show notification
+    notificationBubble.classList.remove('hide');
+    notificationBubble.classList.add('show');
+
+    // Auto-hide after 5 seconds
+    setTimeout(() => {
+        hideNotification();
+    }, 5000);
+}
+
+function hideNotification() {
+    const notificationBubble = document.getElementById('notificationBubble');
+    notificationBubble.classList.remove('show');
+    notificationBubble.classList.add('hide');
+
+    // Remove hide class after animation
+    setTimeout(() => {
+        notificationBubble.classList.remove('hide');
+    }, 300);
+}
+
+// Check authentication status
+async function checkAuth() {
+    try {
+        const { data: { session } } = await supabase.auth.getSession();
+
+        if (session) {
+            // User is logged in, show dashboard button
+            document.getElementById('adminLoginBtn').style.display = 'none';
+            document.getElementById('dashboardBtn').style.display = 'inline-block';
+            document.getElementById('logoutBtn').style.display = 'inline-block';
+        } else {
+            // User is not logged in, show admin login button
+            document.getElementById('adminLoginBtn').style.display = 'inline-block';
+            document.getElementById('dashboardBtn').style.display = 'none';
+            document.getElementById('logoutBtn').style.display = 'none';
+        }
+    } catch (error) {
+        console.error('Error checking auth:', error);
+        // Fallback: show login button if auth check fails
+        document.getElementById('adminLoginBtn').style.display = 'inline-block';
+        document.getElementById('dashboardBtn').style.display = 'none';
+        document.getElementById('logoutBtn').style.display = 'none';
+    }
+}
+
+// Logout function
+async function logout() {
+    try {
+        const { error } = await supabase.auth.signOut();
+        if (error) {
+            console.error('Error logging out:', error);
+        } else {
+            window.location.reload();
+        }
+    } catch (error) {
+        console.error('Error during logout:', error);
+        window.location.reload();
+    }
+}
+
+// Load locations from database
+async function loadLocations() {
+    try {
+        const response = await fetch('/api/v1/public/locations');
+        if (!response.ok) {
+            throw new Error('Failed to fetch locations');
+        }
+
+        const responseData = await response.json();
+        const locations = responseData.data || responseData; // Handle both formats
+        const locationSelect = document.getElementById('locationSelect');
+
+        // Store locations globally for distance calculations
+        locationsData = locations;
+
+        // Clear existing options and set default placeholder
+        const placeholderText = currentLanguage === 'de' ? '📍 Bitte Standort auswählen' : '📍 Please select location';
+        locationSelect.innerHTML = `<option value="">${placeholderText}</option>`;
+
+        // Add locations from database
+        locations.forEach(location => {
+            const option = document.createElement('option');
+            option.value = location.name;
+            option.textContent = `📍 ${location.name}`;
+            locationSelect.appendChild(option);
+        });
+
+        // Load and set last selected location
+        const lastLocation = loadLastSelectedLocation();
+        if (lastLocation) {
+            // Find the option that matches the last location name
+            const matchingOption = Array.from(locationSelect.options).find(option =>
+                option.textContent === `📍 ${lastLocation.name}` || option.value === lastLocation.name
+            );
+            if (matchingOption) {
+                locationSelect.value = matchingOption.value;
+                console.log('📍 Last selected location restored:', lastLocation.name);
+                // Update the current selection display
+                updateCurrentSelection();
+                // Load data for the restored location
+                loadData();
+            }
+        }
+
+    } catch (error) {
+        console.error('Error loading locations:', error);
+    }
+}
+
+// Calculate distance between two points using Haversine formula
+function calculateDistance(lat1, lon1, lat2, lon2) {
+    const R = 6371; // Earth's radius in kilometers
+    const dLat = toRadians(lat2 - lat1);
+    const dLon = toRadians(lon2 - lon1);
+
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(toRadians(lat1)) * Math.cos(toRadians(lat2)) *
+        Math.sin(dLon / 2) * Math.sin(dLon / 2);
+
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    const distance = R * c; // Distance in kilometers
+
+    return distance;
+}
+
+function toRadians(degrees) {
+    return degrees * (Math.PI / 180);
+}
+
+// Find nearest location based on user's current position
+async function findNearestLocation() {
+    const btn = document.getElementById('findLocationBtn');
+    const locationSelect = document.getElementById('locationSelect');
+
+    // Check if geolocation is supported
+    if (!navigator.geolocation) {
+        const errorMsg = currentLanguage === 'de' ?
+            'Geolocation wird von diesem Browser nicht unterstützt.' :
+            'Geolocation is not supported by this browser.';
+        showLocationError(errorMsg);
+        return;
+    }
+
+    // Update button state to loading
+    btn.disabled = true;
+    btn.classList.add('loading');
+    btn.textContent = currentLanguage === 'de' ? '🔍 Suche...' : '🔍 Searching...';
+
+    try {
+        // Get user's current position
+        const position = await new Promise((resolve, reject) => {
+            navigator.geolocation.getCurrentPosition(
+                resolve,
+                reject,
+                {
+                    enableHighAccuracy: true,
+                    timeout: 10000,
+                    maximumAge: 300000 // 5 minutes
+                }
+            );
+        });
+
+        const userLat = position.coords.latitude;
+        const userLon = position.coords.longitude;
+
+        // Calculate distances to all locations
+        const locationsWithDistance = locationsData.map(location => ({
+            ...location,
+            distance: calculateDistance(
+                userLat,
+                userLon,
+                parseFloat(location.latitude),
+                parseFloat(location.longitude)
+            )
+        }));
+
+        // Find the nearest location
+        const nearestLocation = locationsWithDistance.reduce((nearest, current) => {
+            return current.distance < nearest.distance ? current : nearest;
+        });
+
+        // Select the nearest location in the dropdown
+        locationSelect.value = nearestLocation.name;
+
+        // Trigger change event to update the leaderboard
+        locationSelect.dispatchEvent(new Event('change'));
+
+        // Show success notification
+        showLocationSuccess(nearestLocation.name, nearestLocation.distance);
+
+    } catch (error) {
+        console.error('Error getting location:', error);
+        let errorMessage = currentLanguage === 'de' ? 'Standort konnte nicht ermittelt werden.' : 'Location could not be determined.';
+
+        if (error.code) {
+            switch (error.code) {
+                case error.PERMISSION_DENIED:
+                    errorMessage = currentLanguage === 'de' ?
+                        'Standortzugriff wurde verweigert. Bitte erlaube den Standortzugriff in den Browser-Einstellungen.' :
+                        'Location access was denied. Please allow location access in browser settings.';
+                    break;
+                case error.POSITION_UNAVAILABLE:
+                    errorMessage = currentLanguage === 'de' ?
+                        'Standortinformationen sind nicht verfügbar.' :
+                        'Location information is not available.';
+                    break;
+                case error.TIMEOUT:
+                    errorMessage = currentLanguage === 'de' ?
+                        'Zeitüberschreitung beim Abrufen des Standorts.' :
+                        'Timeout while retrieving location.';
+                    break;
+            }
+        }
+
+        showLocationError(errorMessage);
+    } finally {
+        // Reset button state
+        btn.disabled = false;
+        btn.classList.remove('loading');
+        btn.textContent = currentLanguage === 'de' ? '📍 Mein Standort' : '📍 My Location';
+    }
+}
+
+// Show success notification for location finding
+function showLocationSuccess(locationName, distance) {
+    const notificationBubble = document.getElementById('notificationBubble');
+    const notificationTitle = document.getElementById('notificationTitle');
+    const notificationSubtitle = document.getElementById('notificationSubtitle');
+
+    // Update notification content
+    const locationFoundText = currentLanguage === 'de' ? 'Standort gefunden!' : 'Location found!';
+    const distanceText = currentLanguage === 'de' ? 'km entfernt' : 'km away';
+    notificationTitle.textContent = `📍 ${locationFoundText}`;
+    notificationSubtitle.textContent = `${locationName} (${distance.toFixed(1)} ${distanceText})`;
+
+    // Ensure notification is above sticky header
+    notificationBubble.style.zIndex = '100000';
+
+    // Check if we're on mobile and adjust position
+    if (window.innerWidth <= 768) {
+        notificationBubble.style.top = '5rem'; // Below sticky header on mobile
+    } else {
+        notificationBubble.style.top = '2rem'; // Normal position on desktop
+    }
+
+    // Show notification
+    notificationBubble.classList.remove('hide');
+    notificationBubble.classList.add('show');
+
+    // Auto-hide after 4 seconds
+    setTimeout(() => {
+        hideNotification();
+    }, 4000);
+}
+
+// Show error notification for location finding
+function showLocationError(message) {
+    const notificationBubble = document.getElementById('notificationBubble');
+    const notificationTitle = document.getElementById('notificationTitle');
+    const notificationSubtitle = document.getElementById('notificationSubtitle');
+
+    // Change notification style to error
+    notificationBubble.style.background = 'linear-gradient(135deg, #dc3545, #c82333)';
+
+    // Update notification content
+    const errorText = currentLanguage === 'de' ? 'Fehler' : 'Error';
+    notificationTitle.textContent = `❌ ${errorText}`;
+    notificationSubtitle.textContent = message;
+
+    // Ensure notification is above sticky header
+    notificationBubble.style.zIndex = '100000';
+
+    // Check if we're on mobile and adjust position
+    if (window.innerWidth <= 768) {
+        notificationBubble.style.top = '5rem'; // Below sticky header on mobile
+    } else {
+        notificationBubble.style.top = '2rem'; // Normal position on desktop
+    }
+
+    // Show notification
+    notificationBubble.classList.remove('hide');
+    notificationBubble.classList.add('show');
+
+    // Auto-hide after 6 seconds
+    setTimeout(() => {
+        hideNotification();
+        // Reset notification style
+        notificationBubble.style.background = 'linear-gradient(135deg, #00d4ff, #0891b2)';
+    }, 6000);
+}
+
+// Show prompt when no location is selected
+function showLocationSelectionPrompt() {
+    const rankingList = document.getElementById('rankingList');
+    const emptyTitle = currentLanguage === 'de' ? 'Standort auswählen' : 'Select Location';
+    const emptyDescription = currentLanguage === 'de' ?
+        'Bitte wähle einen Standort aus dem Dropdown-Menü aus<br>oder nutze den "📍 Mein Standort" Button, um automatisch<br>den nächstgelegenen Standort zu finden.' :
+        'Please select a location from the dropdown menu<br>or use the "📍 My Location" button to automatically<br>find the nearest location.';
+
+    rankingList.innerHTML = `
+        <div class="empty-state">
+            <div class="empty-icon">📍</div>
+            <div class="empty-title">${emptyTitle}</div>
+            <div class="empty-description">${emptyDescription}</div>
+        </div>
+    `;
+
+    // Reset stats to show no data
+    document.getElementById('totalPlayers').textContent = '0';
+    document.getElementById('bestTime').textContent = '--:--';
+    document.getElementById('totalRecords').textContent = '0';
+
+    // Update current selection display
+    updateCurrentSelection();
+}
+
+// Load data from local database via MCP
+async function loadData() {
+    try {
+        const location = document.getElementById('locationSelect').value;
+        const period = document.querySelector('.time-tab.active').dataset.period;
+
+        // Don't load data if no location is selected
+        if (!location || location === '') {
+            showLocationSelectionPrompt();
+            return;
+        }
+
+        // Build query parameters
+        const params = new URLSearchParams();
+        if (location && location !== 'all') {
+            params.append('location', location);
+        }
+        if (period && period !== 'all') {
+            params.append('period', period);
+        }
+
+        // Fetch times with player and location data from local database
+        const response = await fetch(`/api/v1/public/times-with-details?${params.toString()}`);
+        if (!response.ok) {
+            throw new Error('Failed to fetch times');
+        }
+
+        const times = await response.json();
+
+        // Convert to the format expected by the leaderboard
+        const leaderboardData = times.map(time => {
+            const { minutes, seconds, milliseconds } = time.recorded_time;
+            const timeString = `${minutes}:${seconds.toString().padStart(2, '0')}.${milliseconds}`;
+            const playerName = time.player ?
+                `${time.player.firstname} ${time.player.lastname}` :
+                (currentLanguage === 'de' ? 'Unbekannter Spieler' : 'Unknown Player');
+            const locationName = time.location ? time.location.name :
+                (currentLanguage === 'de' ? 'Unbekannter Standort' : 'Unknown Location');
+            const date = new Date(time.created_at).toISOString().split('T')[0];
+
+            return {
+                name: playerName,
+                time: timeString,
+                date: date,
+                location: locationName
+            };
+        });
+
+        // Sort by time (fastest first)
+        leaderboardData.sort((a, b) => {
+            const timeA = timeToSeconds(a.time);
+            const timeB = timeToSeconds(b.time);
+            return timeA - timeB;
+        });
+
+        updateLeaderboard(leaderboardData);
+        updateStats(leaderboardData);
+        updateCurrentSelection();
+
+    } catch (error) {
+        console.error('Error loading data:', error);
+        // Fallback to sample data if API fails
+        loadSampleData();
+    }
+}
+
+// Fallback sample data based on real database data
+function loadSampleData() {
+    const sampleData = [
+        { name: "Carsten Graf", time: "01:28.945", date: "2025-08-30", location: "Ulm Donaubad" },
+        { name: "Carsten Graf", time: "01:30.945", date: "2025-08-30", location: "Ulm Donaubad" },
+        { name: "Max Mustermann", time: "01:50.945", date: "2025-08-30", location: "Ulm Donaubad" },
+        { name: "Carsten Graf", time: "02:50.945", date: "2025-08-31", location: "Test" },
+        { name: "Max Mustermann", time: "02:50.945", date: "2025-08-31", location: "Test" },
+        { name: "Carsten Graf", time: "01:10.945", date: "2025-09-02", location: "Test" },
+        { name: "Carsten Graf", time: "01:11.945", date: "2025-09-02", location: "Test" },
+        { name: "Carsten Graf", time: "01:11.945", date: "2025-09-02", location: "Ulm Donaubad" }
+    ];
+
+    updateLeaderboard(sampleData);
+    updateStats(sampleData);
+    updateCurrentSelection();
+}
+
+function timeToSeconds(timeStr) {
+    const [minutes, seconds] = timeStr.split(':');
+    return parseFloat(minutes) * 60 + parseFloat(seconds);
+}
+
+function updateStats(data) {
+    const totalPlayers = new Set(data.map(item => item.name)).size;
+    const bestTime = data.length > 0 ? data[0].time : '--:--';
+    const totalRecords = data.length;
+
+    document.getElementById('totalPlayers').textContent = totalPlayers;
+    document.getElementById('bestTime').textContent = bestTime;
+    document.getElementById('totalRecords').textContent = totalRecords;
+}
+
+function updateCurrentSelection() {
+    const location = document.getElementById('locationSelect').value;
+    const period = document.querySelector('.time-tab.active').dataset.period;
+
+    // Get the display text from the selected option
+    const locationSelect = document.getElementById('locationSelect');
+    const selectedLocationOption = locationSelect.options[locationSelect.selectedIndex];
+    const locationDisplay = selectedLocationOption ? selectedLocationOption.textContent :
+        (currentLanguage === 'de' ? '📍 Bitte Standort auswählen' : '📍 Please select location');
+
+    const periodIcons = currentLanguage === 'de' ? {
+        'today': '📅 Heute',
+        'week': '📊 Diese Woche',
+        'month': '📈 Dieser Monat',
+        'all': '♾️ Alle Zeiten'
+    } : {
+        'today': '📅 Today',
+        'week': '📊 This Week',
+        'month': '📈 This Month',
+        'all': '♾️ All Times'
+    };
+
+    document.getElementById('currentSelection').textContent =
+        `${locationDisplay} • ${periodIcons[period]}`;
+
+    const lastSyncText = currentLanguage === 'de' ? 'Letzter Sync' : 'Last Sync';
+    document.getElementById('lastUpdated').textContent =
+        `${lastSyncText}: ${new Date().toLocaleTimeString(currentLanguage === 'de' ? 'de-DE' : 'en-US')}`;
+}
+
+function updateLeaderboard(data) {
+    const rankingList = document.getElementById('rankingList');
+
+    if (data.length === 0) {
+        const emptyTitle = currentLanguage === 'de' ? 'Keine Rekorde gefunden' : 'No records found';
+        const emptyDescription = currentLanguage === 'de' ?
+            'Für diese Filtereinstellungen liegen noch keine Zeiten vor.<br>Versuche es mit einem anderen Zeitraum oder Standort.' :
+            'No times available for these filter settings.<br>Try a different time period or location.';
+
+        rankingList.innerHTML = `
+            <div class="empty-state">
+                <div class="empty-icon">🏁</div>
+                <div class="empty-title">${emptyTitle}</div>
+                <div class="empty-description">${emptyDescription}</div>
+            </div>
+        `;
+        return;
+    }
+
+    rankingList.innerHTML = data.map((player, index) => {
+        const rank = index + 1;
+        let positionClass = '';
+        let trophy = '';
+
+        if (rank === 1) {
+            positionClass = 'gold';
+            trophy = '👑';
+        } else if (rank === 2) {
+            positionClass = 'silver';
+            trophy = '🥈';
+        } else if (rank === 3) {
+            positionClass = 'bronze';
+            trophy = '🥉';
+        } else if (rank <= 10) {
+            trophy = '⭐';
+        }
+
+        const formatDate = new Date(player.date).toLocaleDateString(currentLanguage === 'de' ? 'de-DE' : 'en-US', {
+            day: '2-digit',
+            month: 'short'
+        });
+
+        return `
+            <div class="rank-entry">
+                <div class="position ${positionClass}">#${rank}</div>
+                <div class="player-data">
+                    <div class="player-name">${player.name}</div>
+                    <div class="player-meta">
+                        <span class="location-tag">${player.location}</span>
+                        <span>🗓️ ${formatDate}</span>
+                    </div>
+                </div>
+                <div class="time-result">${player.time}</div>
+                ${trophy ? `<div class="trophy-icon">${trophy}</div>` : '<div class="trophy-icon"></div>'}
+            </div>
+        `;
+    }).join('');
+}
+
+// Event Listeners Setup
+function setupEventListeners() {
+    // Location select event listener
+    document.getElementById('locationSelect').addEventListener('change', function () {
+        // Save location selection to cookie
+        const selectedOption = this.options[this.selectedIndex];
+        if (selectedOption.value) {
+            saveLocationSelection(selectedOption.value, selectedOption.textContent);
+        }
+        // Load data
+        loadData();
+    });
+
+    // Time tab event listeners
+    document.querySelectorAll('.time-tab').forEach(tab => {
+        tab.addEventListener('click', function () {
+            // Remove active class from all tabs
+            document.querySelectorAll('.time-tab').forEach(t => t.classList.remove('active'));
+            // Add active class to clicked tab
+            this.classList.add('active');
+            // Load data with new period
+            loadData();
+        });
+    });
+
+    // Smooth scroll for better UX
+    const rankingsList = document.querySelector('.rankings-list');
+    if (rankingsList) {
+        rankingsList.style.scrollBehavior = 'smooth';
+    }
+}
+
+// Initialize page
+async function init() {
+    await checkAuth();
+    await loadLocations();
+    showLocationSelectionPrompt(); // Show prompt instead of loading data initially
+    setupEventListeners();
+}
+
+// Auto-refresh function
+function startAutoRefresh() {
+    setInterval(loadData, 45000);
+}
+
+// Language Management
+let currentLanguage = 'en'; // Default to English
+
+// Translation function
+function translateElement(element, language) {
+    if (element.dataset[language]) {
+        // Check if the content contains HTML tags
+        if (element.dataset[language].includes('<')) {
+            element.innerHTML = element.dataset[language];
+        } else {
+            element.textContent = element.dataset[language];
+        }
+    }
+}
+
+// Change language function
+function changeLanguage() {
+    const languageSelect = document.getElementById('languageSelect');
+    currentLanguage = languageSelect.value;
+
+    // Save language preference
+    localStorage.setItem('ninjacross_language', currentLanguage);
+
+    // Update flag in select
+    updateLanguageFlag();
+
+    // Translate all elements with data attributes
+    const elementsToTranslate = document.querySelectorAll('[data-de][data-en]');
+    elementsToTranslate.forEach(element => {
+        translateElement(element, currentLanguage);
+    });
+
+    // Update dynamic content
+    updateDynamicContent();
+
+    console.log(`🌐 Language changed to: ${currentLanguage}`);
+}
+
+// Update flag in language selector
+function updateLanguageFlag() {
+    const languageSelect = document.getElementById('languageSelect');
+    if (languageSelect) {
+        if (currentLanguage === 'de') {
+            // German flag (black-red-gold)
+            languageSelect.style.backgroundImage = `url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="20" height="15" viewBox="0 0 20 15"><rect width="20" height="5" fill="%23000000"/><rect y="5" width="20" height="5" fill="%23DD0000"/><rect y="10" width="20" height="5" fill="%23FFCE00"/></svg>')`;
+        } else {
+            // USA flag
+            languageSelect.style.backgroundImage = `url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="20" height="15" viewBox="0 0 20 15"><rect width="20" height="15" fill="%23B22234"/><rect width="20" height="1.15" fill="%23FFFFFF"/><rect y="2.3" width="20" height="1.15" fill="%23FFFFFF"/><rect y="4.6" width="20" height="1.15" fill="%23FFFFFF"/><rect y="6.9" width="20" height="1.15" fill="%23FFFFFF"/><rect y="9.2" width="20" height="1.15" fill="%23FFFFFF"/><rect y="11.5" width="20" height="1.15" fill="%23FFFFFF"/><rect y="13.8" width="20" height="1.15" fill="%23FFFFFF"/><rect width="7.7" height="8.05" fill="%230033A0"/></svg>')`;
+        }
+    }
+}
+
+// Update dynamic content that's not in HTML
+function updateDynamicContent() {
+    // Update location select placeholder
+    const locationSelect = document.getElementById('locationSelect');
+    if (locationSelect && locationSelect.options[0]) {
+        locationSelect.options[0].textContent = currentLanguage === 'de' ?
+            '📍 Bitte Standort auswählen' : '📍 Please select location';
+    }
+
+    // Update find location button
+    const findLocationBtn = document.getElementById('findLocationBtn');
+    if (findLocationBtn) {
+        findLocationBtn.textContent = currentLanguage === 'de' ?
+            '📍 Mein Standort' : '📍 My Location';
+        findLocationBtn.title = currentLanguage === 'de' ?
+            'Nächstgelegenen Standort finden' : 'Find nearest location';
+    }
+
+    // Update refresh button
+    const refreshBtn = document.querySelector('.refresh-btn');
+    if (refreshBtn) {
+        refreshBtn.textContent = currentLanguage === 'de' ?
+            '⚡ Live Update' : '⚡ Live Update';
+    }
+
+    // Update notification elements
+    const notificationTitle = document.getElementById('notificationTitle');
+    const notificationSubtitle = document.getElementById('notificationSubtitle');
+    if (notificationTitle) {
+        notificationTitle.textContent = currentLanguage === 'de' ? 'Neue Zeit!' : 'New Time!';
+    }
+    if (notificationSubtitle) {
+        notificationSubtitle.textContent = currentLanguage === 'de' ?
+            'Ein neuer Rekord wurde erstellt' : 'A new record has been created';
+    }
+
+    // Update current selection display
+    updateCurrentSelection();
+
+    // Reload data to update any dynamic content
+    if (document.getElementById('locationSelect').value) {
+        loadData();
+    } else {
+        showLocationSelectionPrompt();
+    }
+}
+
+// Load saved language preference
+function loadLanguagePreference() {
+    const savedLanguage = localStorage.getItem('ninjacross_language');
+    if (savedLanguage && (savedLanguage === 'de' || savedLanguage === 'en')) {
+        currentLanguage = savedLanguage;
+        const languageSelect = document.getElementById('languageSelect');
+        if (languageSelect) {
+            languageSelect.value = currentLanguage;
+            // Update flag when loading
+            updateLanguageFlag();
+        }
+    }
+}
+
+// Start the application when DOM is loaded
+document.addEventListener('DOMContentLoaded', function () {
+    loadLanguagePreference();
+    changeLanguage(); // Apply saved language
+    init();
+    startAutoRefresh();
+
+    // Add cookie settings button functionality
+    const cookieSettingsBtn = document.getElementById('cookie-settings-footer');
+    if (cookieSettingsBtn) {
+        cookieSettingsBtn.addEventListener('click', function () {
+            if (window.cookieConsent) {
+                window.cookieConsent.resetConsent();
+            }
+        });
+    }
+});
diff --git a/public/js/login.js b/public/js/login.js
new file mode 100644
index 0000000..a87a90a
--- /dev/null
+++ b/public/js/login.js
@@ -0,0 +1,291 @@
+// Supabase configuration
+const SUPABASE_URL = 'https://lfxlplnypzvjrhftaoog.supabase.co';
+const SUPABASE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImxmeGxwbG55cHp2anJoZnRhb29nIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDkyMTQ3NzIsImV4cCI6MjA2NDc5MDc3Mn0.XR4preBqWAQ1rT4PFbpkmRdz57BTwIusBI89fIxDHM8';
+
+// Initialize Supabase client
+const supabase = window.supabase.createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
+
+// Check if user is already logged in
+async function checkAuth() {
+    const { data: { session } } = await supabase.auth.getSession();
+    if (session) {
+        // Show a message that user is already logged in
+        showMessage('Sie sind bereits eingeloggt! Weiterleitung zum Dashboard...', 'success');
+        setTimeout(() => {
+            window.location.href = '/';
+        }, 2000);
+    }
+}
+
+// Check if device is iOS
+function isIOS() {
+    return /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
+}
+
+// Google OAuth Sign In
+async function signInWithGoogle() {
+    try {
+        setLoading(true);
+        clearMessage();
+        
+        // iOS-specific handling
+        if (isIOS()) {
+            // For iOS, use a different approach with popup
+            const { data, error } = await supabase.auth.signInWithOAuth({
+                provider: 'google',
+                options: {
+                    redirectTo: `${window.location.origin}/auth/callback`,
+                    queryParams: {
+                        access_type: 'offline',
+                        prompt: 'consent',
+                    },
+                    skipBrowserRedirect: true // Important for iOS
+                }
+            });
+            
+            if (error) {
+                console.error('Google OAuth error:', error);
+                showMessage('Fehler bei der Google-Anmeldung: ' + error.message, 'error');
+                setLoading(false);
+                return;
+            }
+            
+            if (data.url) {
+                // Open in same window for iOS
+                window.location.href = data.url;
+            }
+        } else {
+            // Standard handling for other devices
+            const { data, error } = await supabase.auth.signInWithOAuth({
+                provider: 'google',
+                options: {
+                    redirectTo: `${window.location.origin}/auth/callback`
+                }
+            });
+            
+            if (error) {
+                console.error('Google OAuth error:', error);
+                showMessage('Fehler bei der Google-Anmeldung: ' + error.message, 'error');
+            }
+        }
+    } catch (error) {
+        console.error('Google OAuth error:', error);
+        showMessage('Fehler bei der Google-Anmeldung: ' + error.message, 'error');
+        setLoading(false);
+    }
+}
+
+// Discord OAuth Sign In
+async function signInWithDiscord() {
+    try {
+        setLoading(true);
+        clearMessage();
+        
+        const { data, error } = await supabase.auth.signInWithOAuth({
+            provider: 'discord',
+            options: {
+                redirectTo: `${window.location.origin}/auth/callback`
+            }
+        });
+        
+        if (error) {
+            console.error('Discord OAuth error:', error);
+            showMessage('Fehler bei der Discord-Anmeldung: ' + error.message, 'error');
+        }
+        // Note: OAuth redirects the page, so we don't need to handle success here
+    } catch (error) {
+        console.error('Discord OAuth error:', error);
+        showMessage('Fehler bei der Discord-Anmeldung: ' + error.message, 'error');
+    } finally {
+        setLoading(false);
+    }
+}
+
+// Toggle between login and register forms
+function toggleForm() {
+    const loginForm = document.getElementById('loginForm');
+    const registerForm = document.getElementById('registerForm');
+    
+    if (loginForm.classList.contains('active')) {
+        loginForm.classList.remove('active');
+        registerForm.classList.add('active');
+    } else {
+        registerForm.classList.remove('active');
+        loginForm.classList.add('active');
+    }
+    clearMessage();
+    showPasswordReset(false); // Hide password reset when switching forms
+}
+
+// Show message
+function showMessage(message, type = 'success') {
+    const messageDiv = document.getElementById('message');
+    messageDiv.innerHTML = `<div class="message ${type}">${message}</div>`;
+    setTimeout(() => {
+        messageDiv.innerHTML = '';
+    }, 5000);
+}
+
+// Clear message
+function clearMessage() {
+    document.getElementById('message').innerHTML = '';
+}
+
+// Show/hide password reset container
+function showPasswordReset(show) {
+    const resetContainer = document.getElementById('passwordResetContainer');
+    if (show) {
+        resetContainer.classList.add('active');
+    } else {
+        resetContainer.classList.remove('active');
+    }
+}
+
+// Show/hide loading
+function setLoading(show) {
+    const loading = document.getElementById('loading');
+    if (show) {
+        loading.classList.add('active');
+    } else {
+        loading.classList.remove('active');
+    }
+}
+
+// Event Listeners Setup
+function setupEventListeners() {
+    // Handle Google OAuth
+    document.getElementById('googleSignInBtn').addEventListener('click', signInWithGoogle);
+    
+    // Handle Discord OAuth
+    document.getElementById('discordSignInBtn').addEventListener('click', signInWithDiscord);
+    
+    // Cookie settings button
+    const cookieSettingsBtn = document.getElementById('cookie-settings-footer');
+    if (cookieSettingsBtn) {
+        cookieSettingsBtn.addEventListener('click', function() {
+            if (window.cookieConsent) {
+                window.cookieConsent.resetConsent();
+            }
+        });
+    }
+    
+    // Handle login
+    document.getElementById('loginFormElement').addEventListener('submit', async (e) => {
+        e.preventDefault();
+        setLoading(true);
+        clearMessage();
+        showPasswordReset(false); // Hide reset button initially
+
+        const email = document.getElementById('loginEmail').value;
+        const password = document.getElementById('loginPassword').value;
+
+        try {
+            const { data, error } = await supabase.auth.signInWithPassword({
+                email: email,
+                password: password
+            });
+
+            if (error) {
+                showMessage(error.message, 'error');
+                // Show password reset button on login failure
+                showPasswordReset(true);
+            } else {
+                showMessage('Login successful! Redirecting...', 'success');
+                setTimeout(() => {
+                    window.location.href = '/';
+                }, 1000);
+            }
+        } catch (error) {
+            showMessage('An unexpected error occurred', 'error');
+            showPasswordReset(true);
+        } finally {
+            setLoading(false);
+        }
+    });
+
+    // Handle registration
+    document.getElementById('registerFormElement').addEventListener('submit', async (e) => {
+        e.preventDefault();
+        setLoading(true);
+        clearMessage();
+
+        const email = document.getElementById('registerEmail').value;
+        const password = document.getElementById('registerPassword').value;
+        const confirmPassword = document.getElementById('confirmPassword').value;
+
+        if (password !== confirmPassword) {
+            showMessage('Passwords do not match', 'error');
+            setLoading(false);
+            return;
+        }
+
+        if (password.length < 6) {
+            showMessage('Password must be at least 6 characters', 'error');
+            setLoading(false);
+            return;
+        }
+
+        try {
+            const { data, error } = await supabase.auth.signUp({
+                email: email,
+                password: password
+            });
+
+            if (error) {
+                showMessage(error.message, 'error');
+            } else {
+                if (data.user && !data.user.email_confirmed_at) {
+                    showMessage('Registration successful! Please check your email to confirm your account.', 'success');
+                } else {
+                    showMessage('Registration successful! Redirecting...', 'success');
+                    setTimeout(() => {
+                        window.location.href = '/';
+                    }, 1000);
+                }
+            }
+        } catch (error) {
+            showMessage('An unexpected error occurred', 'error');
+        } finally {
+            setLoading(false);
+        }
+    });
+
+    // Handle password reset
+    document.getElementById('resetPasswordBtn').addEventListener('click', async () => {
+        const email = document.getElementById('loginEmail').value;
+        
+        if (!email) {
+            showMessage('Bitte geben Sie zuerst Ihre E-Mail-Adresse ein', 'error');
+            return;
+        }
+
+        setLoading(true);
+        clearMessage();
+
+        try {
+            const { error } = await supabase.auth.resetPasswordForEmail(email, {
+                redirectTo: `${window.location.origin}/reset-password.html`
+            });
+
+            if (error) {
+                showMessage('Fehler beim Senden der E-Mail: ' + error.message, 'error');
+            } else {
+                showMessage('Passwort-Reset-E-Mail wurde gesendet! Bitte überprüfen Sie Ihr E-Mail-Postfach.', 'success');
+                showPasswordReset(false);
+            }
+        } catch (error) {
+            showMessage('Ein unerwarteter Fehler ist aufgetreten', 'error');
+        } finally {
+            setLoading(false);
+        }
+    });
+}
+
+// Initialize page
+async function init() {
+    await checkAuth();
+    setupEventListeners();
+}
+
+// Start the application when DOM is loaded
+document.addEventListener('DOMContentLoaded', init);
diff --git a/public/js/page-tracking.js b/public/js/page-tracking.js
new file mode 100644
index 0000000..0d6e3d4
--- /dev/null
+++ b/public/js/page-tracking.js
@@ -0,0 +1,33 @@
+// Page tracking functionality
+function trackPageView(pageName) {
+    // Get user information
+    const userAgent = navigator.userAgent;
+    const referer = document.referrer || '';
+    
+    // Send tracking data to server
+    fetch('/api/v1/public/track-page-view', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            page: pageName,
+            userAgent: userAgent,
+            ipAddress: null, // Will be determined by server
+            referer: referer
+        })
+    }).catch(error => {
+        console.log('Page tracking failed:', error);
+        // Silently fail - don't interrupt user experience
+    });
+}
+
+// Auto-track page on load - only track main page visits
+document.addEventListener('DOMContentLoaded', function() {
+    // Only track the main page (index.html or root path)
+    const path = window.location.pathname;
+    
+    if (path === '/' || path === '/index.html') {
+        trackPageView('main_page_visit');
+    }
+});
diff --git a/public/js/reset-password.js b/public/js/reset-password.js
new file mode 100644
index 0000000..a1c00d2
--- /dev/null
+++ b/public/js/reset-password.js
@@ -0,0 +1,202 @@
+// Supabase Konfiguration
+const supabaseUrl = 'https://lfxlplnypzvjrhftaoog.supabase.co';
+const supabaseKey = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImxmeGxwbG55cHp2anJoZnRhb29nIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDkyMTQ3NzIsImV4cCI6MjA2NDc5MDc3Mn0.XR4preBqWAQ1rT4PFbpkmRdz57BTwIusBI89fIxDHM8';
+
+const supabase = window.supabase.createClient(supabaseUrl, supabaseKey);
+
+// DOM Elemente
+const resetForm = document.getElementById('resetForm');
+const newPasswordInput = document.getElementById('newPassword');
+const confirmPasswordInput = document.getElementById('confirmPassword');
+const resetBtn = document.getElementById('resetBtn');
+const loading = document.getElementById('loading');
+const messageContainer = document.getElementById('messageContainer');
+
+// Nachricht anzeigen (muss vor anderen Funktionen definiert werden)
+function showMessage(type, message) {
+    messageContainer.innerHTML = `
+        <div class="message ${type}">
+            ${message}
+        </div>
+    `;
+}
+
+// URL-Parameter extrahieren
+console.log('URL Hash:', window.location.hash);
+const urlParams = new URLSearchParams(window.location.hash.substring(1));
+const accessToken = urlParams.get('access_token');
+const refreshToken = urlParams.get('refresh_token');
+const tokenType = urlParams.get('token_type');
+
+console.log('Access Token gefunden:', !!accessToken);
+console.log('Refresh Token gefunden:', !!refreshToken);
+
+// Prüfen ob Reset-Token vorhanden ist
+if (!accessToken) {
+    showMessage('error', 'Ungültiger oder fehlender Reset-Link. Bitte fordere einen neuen Reset-Link an.');
+    resetForm.style.display = 'none';
+}
+
+// Session mit Token setzen
+async function setSession() {
+    if (!accessToken || !refreshToken) {
+        showMessage('error', 'Ungültiger Reset-Link. Tokens fehlen.');
+        resetForm.style.display = 'none';
+        return false;
+    }
+    
+    try {
+        console.log('Setze Session mit Tokens...');
+        const { data, error } = await supabase.auth.setSession({
+            access_token: accessToken,
+            refresh_token: refreshToken
+        });
+        
+        if (error) {
+            console.error('Session Error:', error);
+            throw error;
+        }
+        
+        console.log('Session erfolgreich gesetzt:', data.user?.email);
+        showMessage('success', `Session aktiv für: ${data.user?.email}`);
+        return true;
+    } catch (error) {
+        console.error('Fehler beim Setzen der Session:', error);
+        showMessage('error', `Fehler beim Laden des Reset-Links: ${error.message}`);
+        resetForm.style.display = 'none';
+        return false;
+    }
+}
+
+// Passwort zurücksetzen
+async function resetPassword(newPassword) {
+    try {
+        console.log('Starte Passwort-Update...');
+        
+        // Erstmal Session prüfen
+        const { data: session } = await supabase.auth.getSession();
+        console.log('Aktuelle Session:', session);
+        
+        if (!session.session) {
+            throw new Error('Keine aktive Session gefunden');
+        }
+        
+        const { data, error } = await supabase.auth.updateUser({
+            password: newPassword
+        });
+        
+        if (error) {
+            console.error('Update User Error:', error);
+            throw error;
+        }
+        
+        console.log('Passwort erfolgreich aktualisiert:', data);
+        return { success: true, data };
+    } catch (error) {
+        console.error('Fehler beim Zurücksetzen des Passworts:', error);
+        return { success: false, error: error.message };
+    }
+}
+
+// Formular-Validierung
+function validateForm() {
+    const newPassword = newPasswordInput.value;
+    const confirmPassword = confirmPasswordInput.value;
+    
+    if (newPassword.length < 8) {
+        showMessage('error', 'Das Passwort muss mindestens 8 Zeichen lang sein.');
+        return false;
+    }
+    
+    if (newPassword !== confirmPassword) {
+        showMessage('error', 'Die Passwörter stimmen nicht überein.');
+        return false;
+    }
+    
+    return true;
+}
+
+// Formular-Submit Handler
+resetForm.addEventListener('submit', async (e) => {
+    e.preventDefault();
+    
+    if (!validateForm()) {
+        return;
+    }
+    
+    // UI-Status ändern
+    resetBtn.disabled = true;
+    loading.style.display = 'block';
+    resetForm.style.display = 'none';
+    
+    try {
+        // Warten bis Session gesetzt ist
+        const sessionSet = await setSession();
+        if (!sessionSet) {
+            throw new Error('Session konnte nicht gesetzt werden');
+        }
+        
+        const result = await resetPassword(newPasswordInput.value);
+        
+        if (result.success) {
+            showMessage('success', '✅ Passwort erfolgreich zurückgesetzt! Du wirst zur Hauptseite weitergeleitet...');
+            
+            // Nach 3 Sekunden zur Hauptseite weiterleiten
+            setTimeout(() => {
+                window.location.href = '/';
+            }, 3000);
+        } else {
+            showMessage('error', `❌ Fehler beim Zurücksetzen: ${result.error}`);
+            resetForm.style.display = 'block';
+        }
+    } catch (error) {
+        console.error('Submit Error:', error);
+        showMessage('error', `❌ Fehler: ${error.message}`);
+        resetForm.style.display = 'block';
+    } finally {
+        resetBtn.disabled = false;
+        loading.style.display = 'none';
+    }
+});
+
+// Session beim Laden der Seite setzen (nur wenn Token vorhanden)
+if (accessToken && refreshToken) {
+    setSession();
+}
+
+// Add cookie settings button functionality
+document.addEventListener('DOMContentLoaded', function() {
+    const cookieSettingsBtn = document.getElementById('cookie-settings-footer');
+    if (cookieSettingsBtn) {
+        cookieSettingsBtn.addEventListener('click', function() {
+            if (window.cookieConsent) {
+                window.cookieConsent.resetConsent();
+            }
+        });
+    }
+});
+
+// Passwort-Sicherheitshinweise
+newPasswordInput.addEventListener('input', function() {
+    const password = this.value;
+    const hasLength = password.length >= 8;
+    const hasUpper = /[A-Z]/.test(password);
+    const hasLower = /[a-z]/.test(password);
+    const hasNumber = /\d/.test(password);
+    const hasSpecial = /[!@#$%^&*(),.?":{}|<>]/.test(password);
+    
+    if (password.length > 0) {
+        let hints = [];
+        if (!hasLength) hints.push('Mindestens 8 Zeichen');
+        if (!hasUpper) hints.push('Großbuchstaben');
+        if (!hasLower) hints.push('Kleinbuchstaben');
+        if (!hasNumber) hints.push('Zahlen');
+        if (!hasSpecial) hints.push('Sonderzeichen');
+        
+        if (hints.length > 0) {
+            showMessage('info', `💡 Tipp: Verwende auch ${hints.join(', ')} für ein sicheres Passwort.`);
+        } else {
+            showMessage('success', '✅ Starkes Passwort!');
+        }
+    }
+});
diff --git a/public/login.html b/public/login.html
new file mode 100644
index 0000000..421c3d9
--- /dev/null
+++ b/public/login.html
@@ -0,0 +1,121 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Ninja Server - Admin Login</title>
+    <link rel="icon" type="image/x-icon" href="/pictures/favicon.ico">
+    <script src="https://unpkg.com/@supabase/supabase-js@2"></script>
+    <link rel="stylesheet" href="/css/login.css">
+</head>
+<body>
+    <!-- Back to Home Button -->
+    <a href="/" class="back-button">Zur Hauptseite</a>
+    
+    <div class="main-content">
+        <div class="container">
+        <div class="logo">
+            <h1>🥷 NINJACROSS</h1>
+            <p>Dein Dashboard</p>
+        </div>
+
+        <div id="message"></div>
+        <div id="loading" class="loading">
+            <div class="spinner"></div>
+            <p>Processing...</p>
+        </div>
+
+        <!-- Login Form -->
+        <div id="loginForm" class="form-container active">
+            <h2 style="text-align: center; margin-bottom: 1.5rem; color: #e2e8f0; font-weight: 600;">Welcome Back</h2>
+            <!-- OAuth Buttons -->
+            <div class="oauth-container">
+                <button type="button" id="googleSignInBtn" class="btn btn-google">
+                    <svg width="20" height="20" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+                        <path fill="#4285F4" d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z"/>
+                        <path fill="#34A853" d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"/>
+                        <path fill="#FBBC05" d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"/>
+                        <path fill="#EA4335" d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"/>
+                    </svg>
+                    Continue with Google
+                </button>
+                
+                <button type="button" id="discordSignInBtn" class="btn btn-discord">
+                    <svg width="20" height="20" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+                        <path fill="#5865F2" d="M20.317 4.37a19.791 19.791 0 0 0-4.885-1.515.074.074 0 0 0-.079.037c-.21.375-.444.864-.608 1.25a18.27 18.27 0 0 0-5.487 0 12.64 12.64 0 0 0-.617-1.25.077.077 0 0 0-.079-.037A19.736 19.736 0 0 0 3.677 4.37a.07.07 0 0 0-.032.027C.533 9.046-.32 13.58.099 18.057a.082.082 0 0 0 .031.057 19.9 19.9 0 0 0 5.993 3.03.078.078 0 0 0 .084-.028 14.09 14.09 0 0 0 1.226-1.994.076.076 0 0 0-.041-.106 13.107 13.107 0 0 1-1.872-.892.077.077 0 0 1-.008-.128 10.2 10.2 0 0 0 .372-.292.074.074 0 0 1 .077-.01c3.928 1.793 8.18 1.793 12.062 0a.074.074 0 0 1 .078.01c.12.098.246.198.373.292a.077.077 0 0 1-.006.127 12.299 12.299 0 0 1-1.873.892.077.077 0 0 0-.041.107c.36.698.772 1.362 1.225 1.993a.076.076 0 0 0 .084.028 19.839 19.839 0 0 0 6.002-3.03.077.077 0 0 0 .032-.054c.5-5.177-.838-9.674-3.549-13.66a.061.061 0 0 0-.031-.03zM8.02 15.33c-1.183 0-2.157-1.085-2.157-2.419 0-1.333.956-2.419 2.157-2.419 1.21 0 2.176 1.096 2.157 2.42 0 1.333-.956 2.418-2.157 2.418zm7.975 0c-1.183 0-2.157-1.085-2.157-2.419 0-1.333.955-2.419 2.157-2.419 1.21 0 2.176 1.096 2.157 2.42 0 1.333-.946 2.418-2.157 2.418z"/>
+                    </svg>
+                    Continue with Discord
+                </button>
+            </div>
+            
+            <div class="divider">
+                <span>or</span>
+            </div>
+            
+            <form id="loginFormElement">
+                <div class="form-group">
+                    <label for="loginEmail">Email</label>
+                    <input type="email" id="loginEmail" required>
+                </div>
+                <div class="form-group">
+                    <label for="loginPassword">Password</label>
+                    <input type="password" id="loginPassword" required>
+                </div>
+                <button type="submit" class="btn btn-primary">Sign In</button>
+            </form>
+            
+            <!-- Password Reset Container -->
+            <div id="passwordResetContainer" class="password-reset-container">
+                <p>Passwort vergessen? Kein Problem!</p>
+                <button type="button" id="resetPasswordBtn" class="btn btn-reset">Passwort zurücksetzen</button>
+            </div>
+            
+            <div class="toggle-form">
+                <p>Don't have an account? <button type="button" onclick="toggleForm()">Sign Up</button></p>
+            </div>
+        </div>
+
+        <!-- Register Form -->
+        <div id="registerForm" class="form-container">
+            <h2 style="text-align: center; margin-bottom: 1.5rem; color: #e2e8f0; font-weight: 600;">Create Account</h2>
+            <form id="registerFormElement">
+                <div class="form-group">
+                    <label for="registerEmail">Email</label>
+                    <input type="email" id="registerEmail" required>
+                </div>
+                <div class="form-group">
+                    <label for="registerPassword">Password</label>
+                    <input type="password" id="registerPassword" required minlength="6">
+                </div>
+                <div class="form-group">
+                    <label for="confirmPassword">Confirm Password</label>
+                    <input type="password" id="confirmPassword" required>
+                </div>
+                <button type="submit" class="btn btn-primary">Create Account</button>
+            </form>
+            <div class="toggle-form">
+                <p>Already have an account? <button type="button" onclick="toggleForm()">Sign In</button></p>
+            </div>
+        </div>
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-content">
+            <div class="footer-links">
+                <a href="/impressum.html" class="footer-link">Impressum</a>
+                <a href="/datenschutz.html" class="footer-link">Datenschutz</a>
+                <button id="cookie-settings-footer" class="footer-link cookie-settings-btn">Cookie-Einstellungen</button>
+            </div>
+            <div class="footer-text">
+                <p>&copy; 2024 NinjaCross. Alle Rechte vorbehalten.</p>
+            </div>
+        </div>
+    </footer>
+
+    <!-- Application JavaScript -->
+    <script src="/js/cookie-consent.js"></script>
+    <script src="/js/login.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/public/manifest.json b/public/manifest.json
new file mode 100644
index 0000000..1f6a52e
--- /dev/null
+++ b/public/manifest.json
@@ -0,0 +1,55 @@
+{
+    "name": "Ninja Cross Parkour",
+    "short_name": "NinjaCross",
+    "description": "Dein persönliches Dashboard für die Ninja Cross Arena",
+    "start_url": "/index.html",
+    "display": "standalone",
+    "background_color": "#667eea",
+    "theme_color": "#764ba2",
+    "orientation": "portrait",
+    "icons": [
+        {
+            "src": "/pictures/icon-192.png",
+            "sizes": "192x192",
+            "type": "image/png",
+            "purpose": "any maskable"
+        },
+        {
+            "src": "/pictures/icon-512.png",
+            "sizes": "512x512",
+            "type": "image/png",
+            "purpose": "any maskable"
+        }
+    ],
+    "categories": ["sports", "fitness", "entertainment"],
+    "lang": "de",
+    "dir": "ltr",
+    "scope": "/",
+    "prefer_related_applications": false,
+    "shortcuts": [
+        {
+            "name": "Dashboard",
+            "short_name": "Dashboard",
+            "description": "Öffne dein Dashboard",
+            "url": "/dashboard.html",
+            "icons": [
+                {
+                    "src": "/pictures/icon-192.png",
+                    "sizes": "192x192"
+                }
+            ]
+        }
+    ],
+    "screenshots": [
+        {
+            "src": "/pictures/screenshot-mobile.png",
+            "sizes": "390x844",
+            "type": "image/png",
+            "form_factor": "narrow"
+        }
+    ],
+    "related_applications": [],
+    "edge_side_panel": {
+        "preferred_width": 400
+    }
+}
diff --git a/public/pictures/favicon.ico b/public/pictures/favicon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..5f2904b6066949fff4ce6195d013e8a4b74f7fde
GIT binary patch
literal 15299
zcmaiaWmMfj+ih?t?(R;JgHxdB!QF~G6nA&0xLeUek>c*|Zl$<OaVdImF7Nl=ANR*y
z>&sfnWM)>9N!GLX?Adt$01AKuFff4kjRFvX0e~;>X9NWQtuMm?K-zm71;u~s1V{kj
z@V<jU|E=R;0>C#c01y%RZ=LS_x*Tc%h*VaTLj6GW;k^}AMjEX8UjF9^7>MxiNAl}8
zV*r3bkO7OTduHb(PdccZ;|%4wY(S>Yd|iv>ksBL+qeH`m674{9Sz|jHzx=|XWM#&}
z&%`h_L1AwLQ9EttiS#L^gk4hmD+ed7z!4LnQZaDDpMY!K_|GO>_nROaU68I}3Ekcz
zq4s3KZWl%8DRHfIL?|Ev76@ls^pJ=xG6*PUwrADtaI85P%1j2JYL0&fY;pf9l}k0{
zN!xWFL^*WjXnlTS9#QdE8y>R3k}MfQYv@D(YRY2_@}BoRlEnO8VH67`F$hJNzgTl?
zv%W^k2Ph?JUvLhcwqFcb^ebL2&W?)!m^*zdcuo8sU(B7Uhsp^r_8U;gaoOkL9|BTF
z;PaRG8cf8KEjJt)1Rf`}fu2<g=)ht6F{vEaJ9#ZeV)q79YqEVdzxdNC1FK`ppFh-t
zN*A`98jV`{O!?8#KlN7XPUn%gJ^Ard6?9zwE_6=zq29#SGR{#{QPxRlt)^qF??m3#
zgKPXKOugKSl!Z<nfn8~5_EPlmNcPDeZ5aO%X^HenZeSpa^c(n3UAt4i)^xN|H}-@&
zyNA>7A^(Wy7Z~XVuJT{C(t)Q|dlpZhaJumaSZ%(+nnlcW*Ud^{NiOoPCx6Q6^f<w4
zXBBAuDg$xrtpXcWB30-`%}&~;nxBabOa&iu2j<o%u>J6aJf{S3-NBgl<C-<yCdjsG
z!g=EAy!;};7h|__#+D$K5EAiPcxD!bk7z}kG1)_)KcMdl11H+aD<pfk_*8jWY{vcC
z)~^8xR4Dx6`@HlRz2uqM*roVmk=H`UPzd7q8hSj{&Ea>v%Lqm)v2h)VYE&+zbH+Nx
zUdS{)!=XKDp6859Cv!aJ<P{=c)`baG2J9YgCiQT_OFX)6RYyHHE`O*up2eS$$K!Q^
z=9k$|-!%ALUT53mwiR)~_wFi2I)2zUpRdlpiJO`eK8WtkXe82iY2QC?4Gt~@BhK-A
zVkO)PuFWPv{qP$XgEa9Pc-ELtFDM53^Fx%+#{=O01srwv!jUn{ANC^6N`Y}4iC>BT
zayzTiz!lQHBLk3;Py|<r83q4;@be!;68sN-wmd%H0|4BQ|Kg`oL)SKC825E*;yGQv
z+T-#uSVm1#i=Bl|C9n-s6fP@+j;=I9)r31$N5d*>RXjL_NA@u(tQlO&Bq32&Cd8#0
zZPI!}8Jq!^7-68CBO+sM!Z4H{#LBZY)ZF>z^2zUC5sgGF(`D!6EbnGE=fR;s&!lMQ
z#8rK7ZcyS63nQ9)+vl%q=J{_?AnXWFQAeiIBx{6<ldm=lpDc(JYWoHg*VJFqQ2X^_
zH`pbFvi)j|$-sdw;~wc0_JU>^gH)n|uD;&Q75S8u9YWi1N(uP3Y5o-oaJAfE>w4u^
zY%w@Lj=21sfJx!z6s_<Fwam9tBhj_b&L$m<zk40b3EDSPkR9jC^moQQBl<>YGg_fl
zNzZKMa6KbK|8UYy`2UNyT^)z`y?KDK<#fhzL7Y%qQi^+7F|nkHqMqHko%VV-p9t?&
zJ#%ro=&$<m2cKttfx_wno00&lpJgs>W=wCHho2xj`KKP=v+!uXr;#tgC?7bD{8HUe
z%Iy})%vz8yRA<KFESWOd-_yQ7q8UrCrt0vcozTMs#OH^46Y;joB#TsY6$8$uQ0wXU
z?>x>wu|k+%;||X(TGL17TOuvY6r6pyc<rPS<AEA(#H<r`pGT7YZ)^oeK|b5E<`pd^
zq<=3@GDgtEXm=R=IKrLnf2+CW<1wv~U36TRc7m&#^Jt+&rnl6SuJ)N_yogUCL>p!p
zh7-6c$69S#?#E%)mgalQ-R*JvAPFY|Q8rQtmw)qw;`BB#D-JEC9yi)aY^033cBooe
zpN#sS`(TEL$gg)td4E2~&|>jUHJI8^?oyU%T1cEvGBYIndKt4;AEHxvJ|N)x9pP6>
zSf1yPLuUxRm7Ok+teg9GCju$+hXRuRxMO5ccsdnie6LjQ`j^DGO%?5VV%KTM=6m6K
zmiZ;-WjiBFnDc`!v*?houdybtZR-cBKxuv|6RO+TzjOjSjZ>B;HAY{hR8?yV3^-OP
z)fh=J{qMV`^gk=9z7|?N(V=A#i*^M^qo@)uQdw4*E)b#c!6$QOW_Ymx5$|ys7;7Ks
z1_X6_ih&&0317%$RFcM?vQqdQaFGPK{YEAK)}<>V#i4{CGGQVRfK}_F=tKYcjt&LJ
zT3KGajo`Ncfk6^@+CQg>ZT$6eC;Y}=U(E0`;3+k}$rk3~N5LW;)h`&?Y}4ATMa7;u
zrcHxp<Cl&?PEWsayiYMKNO@p)NG6kv!w2L}^WJCV&G-jVJHPmqnj_j_t%In)eid#A
z)@o03=|jq$?xY+j5rk8C)Pd_h!TR5Gh$%}=qUqG9&Ml*10mRXR(5s9}cMk1l^iaRT
zKdc}f*!<Mg=i+~z@St^<+nKz=O6w(A++yXF^i9ubyP~?p;QMLB5zH1PSTbqvT?!L8
z;Pj9o^gbVDH#ax$q0tm#-Q@Fkm^X7_O6|ceJ>dE-s4q;ft;w%ZZq2DZ!xutRYBpl5
zc0FY2eC4!VCLTeb$1(Vv2lWaI-~fLR$r#c;q|3}qBb?j#`i(XT#ETmc@-s`7cpT0N
zdpZ^2%N1kW=(wJ6b{cST4r5Cpv_9ms^67egDofiyO?Ip1vuO`gMHRU@zRGy@UmXjs
z%$#a&Co-4@MazHfZF*~ooj5f70Pi#UaO8?Cc=_dJzrDH4)6@NUiLq?e6@OSai~6(L
zDVlY%MMafR@lGV2#f?;~x);JkgV`c%po1RI8}f-E-%Oe?xA#@t`ligNIwBRiEw?%|
z6wkhCg4g|4+M_Wjy6A7uh}pnFG^gL~sG%2m*WDppG8+j~yn+E{mtl|#Md{aySqEiv
z_mf_h+x}?p^XsHeLd1zbSGVcMnTx`!EhizzZ3t-b9-p86kD}#5<@e`w&(bLSnQK}s
z?V&P&VwC!KWP2fpy$L@P=SWV~E_M#0{x8H%@!n7IKg90h?R^6Ph@1Z<_IXX47>#+{
z*M*g*HJ3cj2@uLOA%?O_aSRJyw6X<5e1W>HnuRTj%zQ>t*B=7xMq%&ol0O$#$o;@S
zi!E(`ez(GbLcq4%k5m2C_!Acw7snU_e*d$_zR>iB&+Ra&mz(8-ai;6br%@q+r>BMH
zMI9fOEiw5}B7XiGxHGt!nb~|wG5k76H>s>bWuG0m2^*wPS;-_|{?{CApU7SeKO|pV
z^R0LN0+nWeLNN1JR=X0p=R-&n?ne}Wt1-&jhVF?RY6?Ql*vB$}hEcIPFPu!!9I<l|
z!5*znbBy`12g&u%aHJ-L%HIi9Y(7$?;uL0Y@K<lWU3pm?RA?ceJ*6}D_CIj6LS=zY
z#M%zI;C5wz-@Q<%I=)l^dcurJ?GW<sepUiPuEA|6H3Blw;LQ&t4lDX0PgtFbzFCBN
zGLOp5tgdRx2bXoRy-Xe5d9c=-J6zs))BgPVg8@zL_l|$gqcJ}+CW$aIA|f&fsU|4V
zN$x}`4z*x+vbB<N_v#fT`qZMuTfcD((k{NL?=@{=`ThR0Qnr$rHQkm}k0TxBsLQ$R
zMhfHR@B5qei?^3?%Vq?-n0#gg0U!!nh#NeM(w4Uzews+;X|59C1|E<H6Hz4{3E4)`
zf2%(7c7;@Bns;k0Ev(rl%3p=TCXLcGW3;*n#81#xt_-d$_bx?Henq8%R(`|~1riqc
zT20Z%PS`|kUzt%(ml1H0`U#OSdhw!Cv_P84=yRJ73)yXX>l^<48~L9st(=@C!&49=
zW?sXPOO3Bfj1Lc8z-2@G9N}740LH<O0%MZRmB?HcMo)A02zH}M$1s2=8G${7OMJMm
zXvQ7-uMeW8=5bU}`giHGn-wFjx8cS!gl7d>+#{TzVjf3bmwJUik{7Cp_w(<ggsO)x
z1Scc1f*1_>(2riefgWEe4?S_z7MLaWXDpO!K}_k3)E*V+;tn0?j6{wj;<XM0emVLP
z^NMp18_AONW9g-i4>>I0s?y3(h0#JsIpo%2yLC=Z_5gAcrUC6wyg~y=9blZF<fKE}
zB~3<Syj9@a%<7<iAzL1FlfK!5mD%*;zGnf4p*{24`#oMZ3Ifvpj=VKkO%xJF1tX#x
z<on-pi(eo#$uj%urcqE7*huRIKO<$?hZIwC2SO=6hu;^~v+uTl+|ycReLC6=kjyV3
z#|ZlHgs71wI^0+D03Bz$5j6|*O~vI}Cjt?u;S8Efyx;R3*?<O0ha~ADl>3WQq73W*
zDg18R*sq7)i98MgD4fvpqhv-%1jEmT?LuVYDQk@s89z#LjF5hYB8{f<X+Yp~&<iWI
zsg_J2gJFadskr)iTHz(IuvuGJSvrad=)FDmi0LA}GEU_*b75m<*AGRf+9VVD(Wt8|
zTtHtRMryt>(XV=hL?A`=QlhgOium@D{IS>K6|JPjaQR_ez0_ts<PQ(1x!y8i&F!2n
z|5XLUn!xP<Ouv-1#BEBbFd<h-_tmyl|Nc}I+c5f%+Dhq&hKUCvE}<K*xQ+L8A+)%}
zxek>||KS|CEvXaHt4(Ww$86{9T}DsFk1U@lWO8R+qCksp)pM^m<0P-PyLc@dk9nCg
z<J?iIG}A;Gf|6w{H&u}~+DoCPsw$)rP$g1L$y9?i(x)B$9w#8RLhWSV&F3|Wi+tgI
zdDTvMN5j}SlStAObb_xb-~NLjw47dzQ4-OF#8vPE?j;nJi7<)@9ckp%LB0fZVCfDQ
zln^T0&JSuQJfkH%4s`tMWdxs%0Dtz#_K*f)Qt+*T_TPoW!q7`wzKPrtJ$3*Q7J5L3
zhP7MTl^Gr?;8@R|R&X8FD4s7}sED6XNCDvDBP0JJwd*+8_a&X|p5tido55^xJC8le
zoyVD%hi-pi`})Y1iHZL-Uk3^JkE}`MkdP47fL>cbB}NwSc$p_O%8E>D;)|JW`S|Lp
zj19t9#!?C|qi1fj=@UE~3dIyH<Q@eijY;37RwJ@nuY<?+qxmUVHT({qZ0bq<!Nh!C
ziWU}iya3z19CX_2OLo;n$5Dhz#|k%kvA@aN8jn&KIj_{1?b&^0P;uF?LD<306EGz>
z%2Vf@tue+$4J>=i4~azvUORMH6XGLz)*qHj2A9cKO&q&F;s_fHJ13`04}{Fd1UwIR
z&)n~-l|{%>dQ@oMcHem<lq`lgvYpJ#Vv~1lAUefAC6{>f<Y7-5D9J!!$~wsU;dB<C
zfBw=T9jR91UIChU)1n*^YPFd>-97l~+`r#^5xck`xKwWkK}YTkNo!EOl-tK(r}QaA
zI1OV^*SCL(iYmYQ{4x!G^yX1)_dL=E`&t>dys3P3L&tY{f)e2^R4uDF57TZw*+cd>
zpT`Z$?}dSFHhzj?bbu}*qfCX?<Q4N)V>~{|>dTpQ>u+>}+#X+XsN~nM>T=<86IY3Y
zG6#F5a>Fz+Jv7Fv)E_p2&Z;Z2olkf@NZLfjk7Z6;<<;pI$OJdmJphWsA@wmgXbSde
z{BZd0v*0y|M@6pNk9=`g3+hu(HeLhrP=F(ym!{+|Mq3`ZR=CmjB4(dkPWof2{{c1Q
z4XW`5DKF>4afAT-eNQt#0uNT{i9WlQEpnJueiRc9{1f^4il_O^AEqc>9UT(D){uMm
zP-}PrSK!Mue*(_-6t0<w#g}h$JfSM$!8y>^%IlD_?kU;Llc?a=spg`x?T-wGT;yNP
zn4{|Mzuf&)3Y_OZh?)Z^q|s3cviz_x+B%T1Z_cS)g|@B<U>x0=U$@hjLq0?FT!&+a
z^7N*5z?hhN7_bx(aRXul{5IF$_wVNC41*9uMsi+`_4)Xq#EM>7ks@YB&))7Exg|mZ
z1#=iQ!6+Ew!`Qio2Drh$FEVZI6`qcds%eIMgIwBokRf^iw9b%jvBFl@#wKLJpz-J^
zsJpXhH+_;3Vef>BisE$!E{x?Tz0m5~vL5f3OkTQN%r0f!?x&D}dEG}Wi>e$4o_jF`
zFrv(-U27x-s$(&WLAE5MmkZH1@-xFLLrV&t;mN-LMHl_YVgmh-F4Ba4`1Wodt^ZdS
zooRbH=FGdj<@j7cI{jwP6`<G}BRl@o_H2bylr~)k+a)C&&=lEaS~c<HQ_4{0SdCxH
z6?5e$Q~nXhN}|hGz$RgY1sM$oCYr?r1yT@DPkaUOq}iP*IXtELD81d&ETb7%)7h19
zK1^D2UFe=e1R%NB0tdNr_v?Xm6MyFCX#>CfK>n47ZtsnW0(4%Bk~TXOq%C~;foo}J
z$Nh;4KKSWP%4m!u8l_(Fno}F<EC1X&O8o=}^47$3HuA;spuE6%F$$lQ8SsO4wREQv
zUmu*1Zgs{6JBK2&SkJB!D59E*X6JS9xsDr+PJ5u=GEGkCRabLx`?B83Lk`qU6g0#9
zsZG3ja8^0E<>KUq-294*9)$^<Uo|i^qqpX{?}AYNycNTZ(_&(V`U%x<!~+1vs~8nV
zgQ^sm!FXfQjjW!={ZaWoYqi^zp9(sGndb@4FG?=;@jadX&G2R`+U^)fWIejgFR|uS
zX|EMLzNp&UEk+_fWF37G##Hc7LEkt<p!ZVpKbroF@@g^VNi>#|wn5U)r{x$jT(7a&
zvu8yKxOk1W5JH0e$Y0CfjSZv2FQ6es{J<i7E<ens<%k{Dmlv91r8dz|$oL4rBFWIC
zBJRfx=OjZ>^?-n2<qtGC1ZYo1?03;{;!RQGT6@?jWveyzi!<@XEWaKfA>~$FtD{Vd
zk_TL3*)Ke5a%mbKx>?=cC$HnlE@`e~md|nqr3vm*-#*{@(&ghI(E=Fv>c+;VBB}uF
zVHC0|76=}|M52|J8O)vDI7~Ru_@Dv4)6DI-tjfXnJ8v3yw%hwjTRuex-P0PJp&dA)
zH@^&F$CUL=Z<Ki&?2rO~03Uecn=y_!B2p_sOioinGIF({c3XPOvQa82u~o=CPd|0H
zyhU(7wZ+G2F+RDF28amfZ8;WCXU~RZUU&{2Q(jfAc-_qXj@zsnml%iWu@u$?e;0}@
zM;fB1qzf2#L=0O*-(9*}|3z{x<*P`&bS=u&rA)uv)61<I*`mRJlP2VO&}o$_{X7iE
zl2w2Z=^w-VaZm9=u_R{@1p%u4QPV-+hQ93lCJJtJ$RbJhna2x6(a%E=SlR**(9p&l
z>^83YhnvmW{$bV)40(G6k}h(>N;RANKH|{Feh!OCIcyKWe<b(n3q3xu+%FN{k+RTy
zdsryq)}`Znxf8e`pq<-b6^OWLJF8}`pKE+8%c(P32oDux@lwSyecJ3f+|U$BgSCOF
z!_D3eq4+AV9{`sWz=z*Rt`)o!)Nd4{Bz#@!<tgZ2T-6PoUwUgYhENT<^oqr@x4cg6
z_V%+vNJLB8SVl1_F2?8deNcjYabmcI+4Y+5Isqm6N;R2(O~9JLMR0gABi?v@5C_pB
zn0-7{h1)J|q*(3Sz9S`Ac@c~|TMD_C;DiFb>v}T;L-M?ot<13J4NWK|Y9W_!W^|Mq
z_O=Dp$bj(%;pD#Jz+FPr5m%8tXEUr@H{MZ8lP<%NCov|kwxqC#p04niaFxXs6o<ly
zUV6j8)ClNc5!Hgr-SRE8*lowBerc9g#6}i5BNFsJRR#zu!0*Tlf)VTC6N<Zd=B~)3
zF%yIq6?+WpsNRVT8#L=zXeIeBFEz}VO<(z4nykF}yc=9pB6#eh80u@7tznlT3dWd4
zj1zvexmlkJdrXy6Y2HzlUWK;#Oo+~5E3Qcrh$z*3-nVsrpyDQjT^wKr7jqz1giWya
zz=igDz$5?UNL*a;0z8`_fd^_*Fn_bABRuMmbrv5jCu6U-aLeCb>k<Ommn$csq*49X
z_t~m4uwTPjQ)X&*RR6Ga6a44iS(^`VAK1uYwXxcEpe6f>SpcyfQli0;`X?ySk?tG#
z>_oxSOfFf3xUIuDdJH>Tk=r6<V?DNeLCo5dT9mNe#Im*%fMScNB?$<$<zXmXSiAlW
zjkjZ6oxw}NFO?)<3=7<cVHH<&lFX0e75qCECFyYa2v6=q#zYj3_>Dr0r_j7NYS^gA
zghD2PlK2aAaAJv%)4y+!K0elB{dy92g%3lwihIaZ+ql>8s{WRL*E^B<d6K5SI`su^
zDD<Lh>w7fDNG6}Qg%4P{p37svlCf<Ro2O;n6kRtOy5FA}3I>Y{ug2}zd@~xu<r{|Y
zU7_G{;g=r_i}~jCoL}O2ShBi}_E)9T7BdOiqMt1-1VxBlN(}K%k6L^-MPI-E)ohC1
z<VU@l#0x}-MLcoPpOJiI{~;La<9BGJpjUk*V<S!U^o>Jm-1t7(VPidEL`SOoq7Tv^
z2!>%sDgJ!bhp2=STPx<gMCNM~<0^d6XM_xVBW68YV&Lk*ShoF9>Ev-IK{2tIiZvDg
z?D---z=7l5k>BgkLfyYvVW+K=>++IkvVyRR!ieNxhElvEg8%U!GHn84lptYKPnTr>
zv9Oq@_4<(<DgahJltlt-X~{z-;Ru$Qk!R<LS`sN+<t0q;h%1$NdyYhb2vlNJMj4yx
zz1Ta4jV|kzO^wGme~nO6gZ}W3EylMTHO2{b?@(sMU1ElFofSR%8?Dm*jCEKClRfGZ
z*&}H~7`FocN(i_%=H4_I8z52!FA2@LQz?gSDItQ4D2fut(oUcFQ{;=O=Pc}C1Ha|w
zc(qTVdtk~DW<8OyP#f1=#Ir4VUj2rrvi)g&^xTs=)g(ctwDwL>n8@_3N<<W)*-i!O
zd@mvue*HR6L)U_YaYWF5%Ppz%eP~`7$8ete9NnsVwblpQUL%Q6mv}tk=3Mejm|^Vn
zxT&x;NLcw1p-`KE1+GwTg~*8GF3rU`D**tKTolc!Us(Ji$ReiE$dppnREUd3V|f(E
zjeqJIU4%M@HjndU;HT#EI@!k^01railF(<i`iO_=?uJ!yD^n*L2o+jH!OUHCJTZ~E
zoPm7{m&ec(0cD9Q{tG7X{1pvvxrdL60y<+3+-(eyg)%=Gn13^5T|f3I%4;(fpGMMs
z84aiZ@Kkg#ZM>UKrS{d%<uRUAd8@rAFp;4jA~F`78mDwV(E}g_U;2iY%!>{}L#P;K
z!cCPE5qk;3DX2tUqohF8TOZ5}C*;*VEdG7wp}^wja4UmzY*w4v{3SOiAZ4(6tywhO
z)%=H`L<awZ?%7Hv8)l>z#updgh3vDUU8(rsh}dbXCA?a8(78;#QbtV3-t#gL5vFc5
z6LC34zM$w;FIy}VX6j`eMnV;I$#FOEgw2`)15nXn(Tc<f5C(lGROMhC=Y#1NzSh5>
z)E$#x!qU;1YiVf`NWX4wRP;IOO;xjJIQO$c>VKo({X!z3-O0Dc*S=fl&?pu0ml-!s
zR=?EpU}?tF*(3pDChpt66rzFsi9o|DOI*32ls1c}s3XYZ>6!5vt^#d9qajhdw&X4#
z8e$dPfey4jkkaT3nd8X6BslAZ5e!sl@F@;`e7g;?n_m>_Xu4c*tk_2S+unX|=(bHf
znb+FiR_CX5du1r3aXmu4$t<{}3PGQl(l|f-XOq8@*;FPmUS&~<KVk{{SA2Mjgfy_G
zq9+zn6fHt3KZzYt4$h$G5e_gL9WgvKIg&%KvOQIu9bn$|3Gao*as8B`3?GQXLEn_Z
ze2<|Z%>YG#HRST6Vr0iH9__g^0xWcjcTMeY?0Wq;e4S@*XlT_SJP7T%esFP^ZuqQH
zt;V>f@X%W=0BXiu&I)yAGN6p#HiXEYc`Mf<E@g-a*&(MkKmCXK3XISG+D@0kk+Yn4
zm$iFFIt}C1Xm;83?}ovAVdAO(EsSUq7#U15C<qM<pNJ&GV_XX@&_%dn{*f7SF`_N&
z0szUUgtXN3TTXtlqtG&xI5BA(g23TmR-9Q+wF05n#H+-7N_|Fb=@q8$4G81`Xg{Yr
zQ3z2Hf;kwmdSzpTo;XhGsJ{j{5ecf)GCQ2wFeO$&;9j(z&T~?E<Nd`YlJoG!tnWS#
zCtxIr4AXg*FR*5u2X0~ew;m>@EJW&KwIq?d7S)N1X@iDPbZj?2d2ijaZnBUkFw3rR
z!vALA#mTfUvDSpyQTtNHUz9^7>u`HHi{OsUh(r}UOEkl8Ssf!#FApAR(eXAl)sfg~
zmKG31?^<MAe*O!?G7o|2S;=`h=~uHZb-hQd<&iH$lP5|ThhvGBz3&-kf7$Tsi|d+Z
zizftNu}BpEgvY3Dl%Q_j-En^QIO{alxV%XUONSDC50W<zakUc%Dl0>my{_{X)>Q4G
zpJpWZg*X-JB<GG~7|>!EF(>_1)xl9q;EH`H0=Hp!o^vhEdK<rk5t0wHiv$Z{Ma}Wg
zp9`OHU?<JgyvTs#r```4r(*Xu<e&YU5yLj6-o>Lk1C8zKeb}t-;r*q9ZMXX@2*dU<
zar6h0ku6b47t-MwKw1s+c}>zmUfXv)c63Pl<63WRXiR8>lb)!U@@``}X4WUtqUN}Q
ziw)KmYEvUDX_kz^1nATH1Azx68nvrZ?s$^dj)m0QG-<<qG?Lat6iE%Y%F6MuXRX&Q
z2jGVvbqsW1u|m+0cRvgSiLslRs+I|hi|P65fK2O?n;cITZrGIK{Q5$%0FS+|1;Qu%
z=W(i!ZBXDHx4g@5*@QH)!{N-JnfptPY(3C7Et{oz#=|5SH7CqGAE>1314}FV6khjJ
za*vAEtu9>jF85lTFS7)1c&bGXVaLUr1s}t3v?&vI1#5hEabb+`z-F+(p7YlGdgxoV
z)ry5+Kzo!_EGxcHSEJo=+P=jSG*5ne<>c@uG#clT@8J@Lk?jB2wT9@W2Zc0=s`WKx
z4A)>iEJI}wV{UHxNJqtos4TVW<#kI_IEr@m&uoYs3|_}KTDKjot8ir+w6^c@c)V-V
z$rZg6myLHrLLX^?DOXrgt|~FE<wB?RKFBlm&sDM&kcU8qIeOxv3(o@f$X7V$PuNl6
z`!a+&043C+@$k``+4@tK^*a0869--hD^B7jgkRL=PjyGiuFD4XdZMpN`iGDca^jaR
zc5j&Fe0ZvNYZ~T>EMr-7`<FS>U-5pwCl5fx2R_`fX~QxN&e`HzCYMYeHTso@NTJXH
zgK6#1r#}n*y!C+>sCj%9U;I}5XU+RG|MTO&G}5}`9lDMK?33Vi{QmUqh@@>$hbrc&
zx-SeJWg#r_S1Pvbs>YYT5qz@y-SAaiXpcK3ouK4THI~bNXxpY|q6Gya;?E>7Gf*7N
zIG6=8+YU8Ph`V229fZlqRyr^8Bt|&6)7daFa9poa)VtJp{EL1;Nn?r0V1Xowp}#w7
zbe_eb1$eARg|8+WFRw?9^7)oPfs2XxroRij!J5^lz$KiV6~&?b2CzBKt}ahDyB~th
z4Ry<@F2`m1Oif_{DANe&<))sAiJ_VW$?!f|$(=r8vKF^h^w<4x+qA)A1+&A#oaqNr
z_7_Oc$X`B>GKDqYEwov2hNQvvWp46+l2O_6h2}-RB;dV%PzE0#lL{qeKYM<TbDrT?
zfZJ-ST0oL<+NVI5?nXO-x2gVi@N|U~3g1Vr=QCv!+pSTHJp81K`eY6BkGZPuWjf1|
z4N2QAN@ATmxWlhS%1o^5O&#0xmJaEpfuGiwm)nIld^HI)%a$u!HQvF7`-J9e0XZf`
zsK)8b{OOm2r@AM)Gl_A74XMgzM~umv?2Mipe-kyM*ZiDpCA>@MB4<&u<3hp)^|tyE
z6qHsW=D`-SsvxJC&fJki!Nm*n`E$gy-TpgEu6fDbUtIb;lfAKB8Xm!!&A%KYEBr66
zh{$`t$p5$^WmZlb0Dyn?e_atDFHgPs)PsvPpG}{}U$SX-Ud?92^aFL;ZFbmV&`D6M
zbzwoFX-PG1V)U0ZbDPhzW|?2RWX4jDWPVS|b8@ba_Dn!fY0RVx3arFBMu?N3<$+zJ
z5Idd=9s?R}Rhc54jdn=x!*1%Hf&oaexI}nLxUth?^K-Y$`Ev9>1bRA9f({)2?dlB^
zC;|w4OK8tWHoTf$P-0h;lKKV&PQ}4Tb1h$QB$}vfVi;`B%oxpqV>YQ7y72+kiGrUn
z1umFJoB`zy4w?p~{8lfPVUCr^K!l_m--fXIvLJ63C5Odke_1{hj{-h$@h(B3XV%6z
z>al&xQiyras?`>r8gR7`Z4N+|L_MZZahyMT0x`r8!ggl5hI2owxImK7P3B5E>|_U7
zm~YDMnx~eyJH9Xtnk?!m7yq?QU`=I31|};jIp)@EG0Q#@@t!|XGg5if4%(q~jYVpH
z!007HU4U952xQ41G!kJz%3(9U2za9XTG4@gxl&p~OD<|WgHaQLSgwtqr`_(l|L(YO
za$9gv&HcVg3{oaPvj1v5C4wSnHaLWSUi13_kGNfHD9P*vOTH8csM*Bmk*5H_dhodb
zD1@c=kyeYih7pgC;Lvmz0W2oHEm4hG<q=C(@GZUD(Kea+JNbJ?f+k@PS99G2mnrPM
zFvI)EnK{99Fd4XZ2za`~PpoT)2e6o~Lf?#jC~;CS(0rO;Q}j`z6Ad)(;Yh?W0@Uvi
z+cGSe_E{oQqSTp#`sM6beV-*VC~~yLvc|I#NAxmzBIH_2yE^sFbw<{nZ?do*R$Wi&
zNfhiUcpqDTByfuQgVqoesi@dLwEs-vCPER3m}>%qX+#PEiV^fo3SrA_N&8Uz)jtiF
zOV|(&C6VI6Kh4dCNg!bwK>mHK0{ASy$2Bh;q7*Zq+al;M76&`#!?Gz8XhMH?-P4Y<
z1wm;eGa&stBvPP|p$TQ(i($p9AmY6H*iPnq-iXAh$$GBWAkE9$EbA-X?tTe?)S|?Z
zJ8WO_ze&_Nb4L`zEek1tcf>i-fHWw^A6QN}@$TXSRE|kbHMI-~5<juDr3sw|BUu~{
zH`1Hu{g3k<Y_%>;AmZQUqpj@iaE-bwF<8-nud+}nbamrAB>oeXByWCd%v!tY%&_{I
zq{iV9Z8NQc@J*f3*lc#gq2X`|D(JS;7w3d1svjOYziAW}uMAnpHx)AZw-nT$NPSPk
zONK^l;lp6<c&IB<YEH0PalB{L(Dtj&`-~Z=jhQ1Qf1sa4`5E7@`fMQafWOBdASOUL
zT?-jl)5ge!;qfIir>kL)P|S+xO5en}csWZx{SuF4qE_r*epkQgHU~CDN2S)?dM4Wm
zCQ{yn`ff#8Uvai&T2}XH(A`ZBY;B26a4P2hRcr1+IpSyVpNSP0HjIy2o^$%!Z#a0v
z#v=K42XX8;dlP9<B%scY_7km<AWzktl)TDR5<y2(F@94iDc?;s+V}JDt1P`fj2G*V
zKqec%hF0F(sN%;@G-$Hl?6;o}P4&M615^iM(ZNuv(0wYD)K`0^8H9TbD5onhxY0%{
z_~|0CGA4Tc(DFKW+Gd+8sL5<WdtplS#L-6(*5RdTJydMijN8ff?5J{U=)Z9f3%}=m
z-s}#je&b)E9r%vP*u44wEc^B751Og&^~IEer(pcy0!QL`wYUVi7w+4OrVuT$f=0q*
z!c-ZlFh2~+pFuU)>ou`~GR;Q_--@jkv)xzE&@+H*t#HTE2xxb`&DH%+6i!z9Dk>0=
z2CB>cIfLE2dq&t@F8A!So?IYu5^Y52v85D55N}7%e~a}{;d8_ZaX1VAr&q&GL8T=u
za#gkr5)Jf=f1?g}Cl^~B(wtep<Y&U4Ktj!DHxlp-y|-P|YN8%QZ%gpI_M@rFh9Y$8
zoiMA!v}KWFyW2}@A~ik9?3FH({Ok6IE$g7Fz%{et%VRe`Zfde^spXjHBwS=@AmgL-
zpGh(2bKI?-9|2E3HC<$%R(WRr(Zxud<y8ev{jI$iCM3~);uvDfj7MtLLs0u50)CH1
z8raa2;6g!#5WbkqnfXip3UUgL#>YLfh)@>XSXp(&)Z(3s-{2;%^D>n%kA?LAum_7-
z<^rkp56=R9{OfQ>V^e1$r^8~~(c$fd*u#Kb(inX{e6=n|PBV%BB>VIvV4@dm1#ixy
zV_t7*#0TAS8?lV2jJ%%f-*hyf8r%}d8#rN`F+(@u*|Ml}1)shL*guOC5m}?5MdA4S
z2~Z?a93=s0EL!$6m!s+G)k=D}mw;Qjg-oM8ea83EzE_2o8QML<_Z-6a&(96v&A&QU
zDuB$BE<Np{z;CRf65djfz^O3=7lIqULa)`zEES;hz*Fr|L0&0IyxUNVOg|s`{bg~r
z^Jn=(@$UKdrTDtq`Qlb^QzZ{m^Vm^UkY{6xIQ{w*+6^V*Hfh1>LIg}saOBXf{&Dwg
zl~vd0CE4)zgcZZEH3GiMKkb+dSkvcwp2DIDHNt<()j{S|N1SfssVM?T4ihJnG5+~H
z0#FgZ5D0HE%v@?#0#kx-^hk8Cv7&|*MZkLUwjEG=zd&_@ZpajbdkC>=?EB%xZV2gx
zk*D9`FS&r@v7M$Z1Si5VWg0}D8D(5{c{^<sLMKX+u+uw_T1dBW$WAS`awI|E%;!4u
z9*!j~>FLi_&jdzx6x6J?T@f%!g7F)g8_+!&j^l396W^iKn8URH9ugai-}3<3rEt_h
zVTMHJ2&-=W0n@hkEq`7=t=wCK1#*T7QZ1nx=<K{`>*@im?i0y<-gJJz$ts1E=-|)y
z0AeBwb0mGw>ImiS`aog{()HXOrs%#vynF6vW3Mqqk3huD`z3liiEJDmMZw+{OPBEH
zK{R2PRj2E5{gV|{mI+y_=RmcGs|Zk2(ZTlVvJkPZ)0+>qlbK>KT6!w0(!&1*`F?A8
zvd;4c7LG2yU)VwX=I^Mqo_6#|p%X}gymt$O3VXP(yefE;7a+V;=35DQeY<3~t%W6w
z@4=D%)#XJ=fjDt6nFD;?9bnSfO7DWD;GVESoEeQ~fSV~lL3hxcjq+;CXvRNzWc>h(
zl~DUZdRnx$gt)WYFZ!wZv{2Q9oC0jQ#$fg}gL=CRb5y7DT|s~P;0=l&$R^CVY!on-
zvmol4y|*YYaLT_9SzSp}eA>MVCtx5CQjda*@Ep&CRM8aeXQ(E!(O>^XO?&R$kU}1g
ze_`8h$!OW*<T{zwZF$@eqhO@?NoK|cjf)%~6y;S?+UQ7<fb&kT_8QR14(&%~KU{l<
zlR-t$q3YL}Jm=q0sT7O)OeugLKPi39al1DnX=yWrb!snD<imR<2bp>#9Sk<LuJKQ@
ztluWmJ~U?)T&U5Q&{wuZmTb0@0I7b0@g2Ff3`<%OzoIj%D*}1Fd<i)9Y{jg#%RN=K
zPkib2T6bxH62YA|xx1GV4mKKgqp`fv;~tLX(%Z8NqQ$O*MwaTAM#lZ_U9brU!N@ZE
zqCw=|ns$xE+uBe}A7cGu@k7LP=7(gq(1*c62j&<hMCATyRA3C?ay4p!R<VecZ1wh$
z0msSN##U3Yk4}7%mI~Ac4=Z%i9g}y}+da_BO;!r5?J1vk-^08-sngI^F7WW%?Rcpf
zHQ{j_=kJW^WLyJoQ%^_(k}%9Cz>j>&J#9e#h->*#y`2h6O&g(y_6C{2R$UP41V69A
zc0coZi*0Ryz<3!?o^o-=;^{S|=Pkd>O-e%3t$DIx;u`A3g)kC&Vu4f`zHs1>Vnzlq
z6VyTT6uQA1wMGTz)JkXm!pNIwt#(eU(-RVm4;dBO2N=YC@0~GPFj^SE2@Hkvd<!4S
zTt6Wy3HU@n<SFCD{+-}-qh>$tQrJACu@=0u>B_282t~*7oHS3gpyfPFM@dZvvi=k^
z#to08$^m;Mex-!+p<YF$@odFzGyy^6$68UNe?xE&`#*_>%?wf1q~u@fip~|zNg87^
z>XKRrVr{bl-M+gB0UB>$p8@jI_T)m)L+zYD-o`I~L?cD5LJB-t*X19umeko`l4C(Q
zl_tD0Dt8VsW|tnLej}HSYfkxvz@U~dyE{OjM!9t1ST~_L3A~IRqW)L9(w-PGs~-@2
z|0YPa+{<TSX4LHa@2qHc^^(;5R%7T)*86AC;2j9uGPdqo?R+!0o#3M@B%k_aqDTX~
z<6~c$Dn=kic>5l|^5x+#I29^rn~<oF#bLL7+cwfYk@Q8_O0ud^J(LtiLgkFQL&!#7
zbO;duRV_Dbl|Stifhar}R1IBWy;%#qlm0IgHfdF>KITUwiABtNV<Rb<QZKf`AM}T#
zHkK|8b3t=4y3J-QzrUhkCy9&}mXp*hpxBJU|7_=O!u#!_tip?2fr<!=!Hz_D*c*g^
z`b_y3OdghkM30qBgBz^pe)9?qwKXy#mCD-f6ncTJPVlOeT?99gmWrQDA(9^TQqh5s
z)<D`a9Z6%7ee$NzVYNT!29!i@!2M$l>^AH=4_VzVyJ%0<a4Xu#EzsolmoZ)4&ifj1
zu2iIDyB*Rf){61F*&D<b{HoWA=V^TwV<acEQ(sKQ?<Tek5r0S8!}5m3B3srgIxw^3
z{;%n9z{-%pmDFDrbVmR8nHI*LFf`GC2I>pK112}N7Ov3btUX$&pd=FTeYs3JTV8q1
z7{O)Swbn5fZz=$*=_aCJ1Olue0v0zHUT1Zs-B(KQsSO8@d5#~;sa{3$F22NdRy&=&
zI+V<ru|&e5K(}Ir^$-6*aK@0$?G+A+l_;>s8%Z>>2~<Yt86ZAhUDa?oK}#>x(K`Or
z)nsQi`C>y{60k_rsV`wNP(sKJji|%V0R(b=5k-~bPpc*z`6T5nQ&zhGE8qW%ofAov
z=O1#B?{p>Gn$zv&_TTf<({5IVyTyTPsYNr(VwoaUlf{E`C9_!SkI4*X_P-cyt+f;2
z{)z0az*PUz+Huk+2#y%=Z?T;`M@z`SfBdR^H@SWg+btcsUB{BvGtmc6i)e%H&cl^4
zH1G3;&)(JBvBO6Q;IiYpq9F08V#PbPBD7lyWntu0h6O5g20tL~?zkd<AG$?AM=ttG
z{B~1`fmzE<a?6y?YUuF;aeIv+dDQ$>`P?qppD(?lwaDtaw!KM<xyE)#4(dBGxXWrc
z@h8{>AKPGCY}@Pe(kjcxvRv2%v!lwOMyIc_JF{e;?(c*mB7D9ePArIdvU>A3Qymib
z+-Kp7ND3Ou(qcrjV$?3VJ`0~bZ*g)AMHb)XTC9yZ@jk$G8vXR5F`@z`(jcRpk4NWk
z-{LAy!Tqi=JF-hE3nHMW4odJ!NMOe#eo9s*f^7m$C~ShHG-$lbV`#^YBaNxy5LJ-3
zyif4SXVUzPgD0ERM-q4Gq+78w2ubew?w+G-`~j!TXaS8!SWb2D;{IZSuxpIX+o>XS
z#AM_~XKXpdZ@iL7xPHd3@LT7Ak3oajemhz>Wdz-*v~3*=E&+G|B_V}ke?y<;`WeJi
zxXmAc0QB^A!S6fdo+0#uX>I*Ddq74XJK5(0n17PV(tB?~+}vRJJ~;Af?GZAIs7r`c
zI<A!}N)(OTrXS^t*3252YH18O+TKQU{hJcv!>zrBz|!{0e4*%mV|YGirkWe_pv0^!
zu{=#wHH;@G752){`+V81dNCW2Ghw%^npwwyw--&yLDas2a|HxRGXZ=k?+aRt?|1}o
z04gbJ6E=|WW(VRj>JuAbK&V@DbK8+gj}6Z|S&d?TlU@4Juj#zFKRBnD?KNIm>BH2?
zWN?Un^aKlzjvAmAWwkM9W`cJ=6ZaTCDS3L^ZZpz`r}u&Rn;UWx$|5tK8Zi_AWkanf
z$QaypJ~1O_2k|KG)`1Pw^}i}Rc~5ptN^CK)F^+~)5DO-}fD+MkV=#vUj<~czbGPMR
zI^R}M4L2F7FUzNyBS5;;oxf-(jb$I)CLU+qnibbWITK{rqxA_f5=4tzm+h&>pqF5c
z)YMk<yE$#ioyvz;?|gjDW)B1gOU)6mVAVcIS_e&_Z1WrMhyymrB}`D<bZ8(dK#)F{
zCTIM0Ze~1wbN#!b4PfbOFO^f4eUlwAV3DRsG9Gw{-50AjDH&4X$LXtsAPE3{be8-%
z3$b>FJ_ap`<)s<T1d8c|D+=n2Y6L5G$b$~m`aHLq)R4yJa-{WjK|va~1qR*L_L#2}
z;tixdN#XPx_fASrcMfT7-my{MNi6XVb4k}#B5p6fDc(<sJ{K5Q2yr6lcoZZ^yXhF+
zCQR98B%<~sEs;!wD5%fHHk*lT_6jApJ9$;{?a9@TasN!vwHIFeA&Dm|_T47qS54xZ
zYP0u^y+++leVZRbIU{oT{??%5OAs%fS5vb+(#2pJ!DDOlvP&N4pU%1ZLh`Cx4~Dvo
z83RU~xUKEYFINKeQft(oW21(ugM;DfDJXwj!>LbHiJrkUi-Ywr5ElqeU!Dwqcorh;
zF*zE6PO<`mM;ff<`fw}ce8S@_svTOM#x_{&5Z+)7ZbX~z^cm;*L?)Vw);Q&NBoVzr
z90jdp#oOB<<khQf&Z3}>Qp^|Ps<bASyxQmx)%GY2Kn&JikTN9b{ANX$ezSf*m-y*F
zteQFEzogyy_?R-$kdUu6vlE-;iAzHaLQbgRPv?D?+AVh<KT2{1#rDoTA*k@J!ELvK
z#3j^Oeu+1@t7=u(6&qdovE)D|j*bqO2<vT!Rl5HDea>(0Huin1iI5a7Wg31Fz*X8H
z2>*>qw?C<?$%=Tqs>I`^g#6T3kIXP058^DfoS1Lz>eg#+aM$qjX@}+vD?R;IGBxEq
z8}{erOL~j#Clr+Efs(J|E7cpKd(vO+M1n<RO&kw4k~;^EndG&utd>M{>2opog<G6o
z&fL0T2yn%bhMj)4Z%h2XJaYTYlzShZ_t`iksDjmpwJt~r_T4>~KNPZRR{ZE=p)*pb
z%KUrWN_@91WL4zGS=V%u`r0sH{YVdFXlS{zlbs@qR5<6paEq=#*!R%D-38B1!ghr7
z7}qW6G}@^2De~U5SPPc3UODP{gBjlaJjj()%MSDq=l#oUE#aS8!r9B_sPAjKLROq#
zZm$Q2DdS)=HmwU^0WX&kV@x0{!50aW!t2&%<c$XWUip%^-CW%JlJV9cv|s@&nB{Ki
z_lY~_4KqVHj4N4AjN$J9NohfxA&Dp1E_HMFzto5Lr<YFjUzTt|p}3ge5SqHloBE%D
zU11NFr0cK!d(rRH5@_~R&wSn<Ggi3VWb}!09vo0JeIN1?9xGH|U}r`n3HxICZdBZo
zl9q7$_;1eblwe?s=(((mEBr2RTR(g*4(Wa|fCr9M1=jSByk37FK&o!a=mo!=p0hvs
z|6zK6XNeMpfr$V&e2RexpOjg?C4!6}mKbSlk~#WDHjP;os=Xo?a$XLQg4yEfX;cv=
z+605abn&Z$;%yn$orn1Db6fpZ3az%+o-t~rW?`P16F+3ift&Vp;|X&8cdIf6N9_B1
z8hUQKNAH4l300|lZOvwLXWn|lo|;r5bk3)$fb-wh{C>Si<#Gl4U$qVMR4wgOw;#7T
zo2v9M{*<iDKNdB{LoU1_a3uw*0Emff3O1W*OL=g*SCBL0lVh^RSV~m;tukasL2jQ!
z=5l!ghTKi-QI#Q?J?G%Q)J2oGBx5j{*Y{vm5}~?Rr}SC^S#$!$E9jLR281EjI?6;(
zFwqsbaqh#@Fd?w8w!$>`^BEoLK4c{@I)6q{Ui)5iw?p~{hEv^@j<r)%{-MtV$ES@M
ziEv6K9YXs0056Xco-h_kpCA1o81oj=7+vB^9!QGzZ|ZhneDSTF862Z7OR~IkTgy$@
z>|AiTc{wHE&9Hi;5r?g45~H4&fe|Ow=Op8$vOVyzD7iwF#*CF=FZWMt?}H7#(t{0%
zQ?>M(1O2&v4lr5*Ddu)_5XCM&t0@!k`&*8qpBpZ?AF?{HO^2M#PYA}bAY&Dvi*-;F
zupLr#d%x6ue+o)=QG8QcZqZX;%yyoBw!eI|yL?>O#kD|_;BBrWIe&bW`!NTfo29EA
z$MbJ#ZLF><XTEhGc%z+Rh=ne$yLlrd+m1gneasLl{!j51{>nD3#7B4e)X(z&{w4T7
Df8F^b

literal 0
HcmV?d00001

diff --git a/public/pictures/icon-192.png b/public/pictures/icon-192.png
new file mode 100644
index 0000000000000000000000000000000000000000..556e396fccdd9c818d3d054549b4dfe282f6f0ef
GIT binary patch
literal 5560
zcmV;p6-VlcP)<h;3K|Lk000e1NJLTq006)M006)U0{{R3WdfWv0002MP)t-sM{rCc
zJcJ@Wg(5wLNxbGFJA)!Ug(5qINxbGFK88uV<{~_VDp;3Dy5vc`=195YNxbGFJcS}W
zgd#nLNxSAEJcLNO<T{SPNxbGrx#S`|gh{*RB0Pj5K87Mag*k}6H-ETEy5u4}ga7~k
zO1$MEI)X>J<RnCjSit9#*6;E9{b<JNCryxh&Fn|D;i}*BDp;8@ZmRnI|K#=jK%dY<
zsMfva_9H)rMX%h_?)g5K$u47|JC4INcd<5qw>X5mT~unK0000XbW%=J0QNz?_YAHU
ztSVUR1`FsH)SOk@k7_9bzdU+z{fW!|y~K3yp8x<9hDk(0RCwC#TxpNux)N>a<pUQr
z1l@~Rgx>3M+HqDA2#~Pz|Nqssoy|!c$61)356>e_4?`ezT-&KCcRoJ;ze;O4Q5Wm+
zcr%}mMxzy8_{V&{*^Ji<b+Y`kW&czcSn$zoHdPb=0L&JCp&WPr{O{L%GhV2lf28n}
z#Tbh|Rj9O_1&@ZV?EzG#v(bFKnEY|VudwVuum}KskKz}~boJ+em@GD<nOOJ=0Dylg
zv(e_~F%apeKxP#IBy0M^7}T+(^aQ{)(kcKbhOzoXA!j|GDFC$tz<C2Hv-$e>2c`+$
zd<a@B3gE&0h(gpb`Q5go0Quc-06^66TP;Z)uN2UB!Mi2^K=iQsO%Nts#Fqd-A-vy^
zmg`X$@udI&MH#K%%$64OcCO0+c<Gw{Z2a(azIdngY-SzB#{iyE005kACV!gs#DYEK
z0ANEJt=~iQH&Y0D0(eP%!+Vsl=(GJ~?R8E2lH3Aiv=}^g&R{?J!3_hr%Y6wv-TwJ|
zP$j7Ip4$(AhXF)aITJeVbj|(maA|G1SoIYjz%v%gI7$IP#M*S@*HFH^>~B6vIj}p+
zd=b3j;!`(X-fX-aCiqW5|3%ZlL(YPT0*o(`)rN>hlm6zPSdi{YSr9e0r1Vkdy%DIR
z0py1ez6cXSaxU!V-lB}uzR@4{m)<*{j?xOi0I;{Xr=*<(`(=d1s;~UeyFPZVYhVTJ
zWs?Ba!0GWkdKd%x_190z4~{pypLl7Sw!3>Rd|<EZ#_f8BNB2K}{h<7JmxvxOJ=)8K
zQOugOD8e7mqumRm>55<g`?(uL{zL=Biez*^n~)i3{8#jA@k8<->Hh2PZNH0Uik{M$
zIA7TNSBoz3v$y?tu^_i2!mfOabSev!^nzS|;|s#p(R4W(AbwI)&~Mc6q4%V(9x@uh
zY*f=T`Co`cQ?+gW9f1Bk=$@bAZ-U@O{8Ew*ou6(jKaND8Lrz|92FSmJKx<J}!$A64
zl90m0f1+3F_R6LWvl~xar(4c0Vi9yV-*NawB)ZG0Hs;i)?DFYYUjFs0rS#|HiJwvR
z8)AYgiHWjRCFP{r&ddL2CS4z>?E)wv3x<2=Yk&nn6O?RKNh48#fWwt4>%gt{A3Y<I
zsj30eBb30+Y#<iNxJm*b>e5RdBk9QP9GKQmG|M8M6>ATa%J8H~=`05T5s%kd3nGp@
zeuD#~X_MJ&rlF2)<`Kt{7$|Q>BcK!I5>Cbq+Gb!c%bFGUjLn#4Vu&cM(`79PJZKOt
zUoDZ(T4w+n-Kh$09^bljWB+>HVndTu064iiPpJ~wVBI<cBtB5_xWvB`HcI)ZWFAiK
zvg`sh8>|PXaOjcJu1f1RAwVgs(QYT$W>a_$14okqBTy0^Z>bwsRDex?r|F3nj7NF@
zYmOzr#4NeZY-J;C!OcMXMYv;(V8_|v^XukDQDp2MM^tzh0`Gk07C4a5KAsQ9kw{P*
ze0JlY@cfAMIs_1Ur{nc{JOfyQ{lvxo?W+obau9A{j^Cbt)=w}x_TZrRm1MKs6+m8F
z2$rlRu`OKnR{g?DGYiLu#eO^)b?464WY>(RRG>LOj4b+=K7c(qd8eimS?kBkagQPZ
zrHlgSEzk_%spZk>SyNBeCcQdFq4sN{-_v~HHYy>t^2AaKm&2!4ml(6fr=`6V5NEA4
z-Z!<dVwRMyh>gBEHo-K6uY#Tmz@EI%8wq=1$|6H=1^`<kq#jIqNcCU9Q$b$^q~tB_
z<-7z+AiZh^0JGKT6$x^RPzCA$W2B?YwA2K=p`ZbVLqYVF5i2om<)~mh#2nzxQXls!
zEVrr}fO&A$#4S8jRY9K|z!JNt&{9J(PMj7JOgpQ&iCW18>mdeV#E}b4!53<5-)hPH
z9(s8vTkHVbbi5p(6IY<734$k|t(}=X5Jw?+-Wz#0vAJ%8^I~PwiH7oPsX}A6W+YJP
zKNBa0$6cPArFz&UQo0#R{&>vJtlbqs@d$vB&cYz%CPk;l!@Dp~2Y7?`q^Peg;|S?2
z7H*P-f5DB1ap6n{`-n9o-Q8c$AQ?I))S6*K#w(s3WY>#QaE%);HxLYops=F^0<OpI
zr?Ush!1a2)p1hoM>bsp$)R=7Vj;SptD=_GS;L7-9j3IJ&xBbmE$a3+&BIdoql{ZiF
zF009VEGU~$6a~|g-b!KW$61kV>x;FaVJ#?8!s+4Gi&?wm6#&5IEis6JaD2F0TL|(4
z5GD>SrU1ML!s*#k3vCntri-)^7*c8kO^8s|k2pPy76>Fr5T_~_iU-kUTHz(MOqBOe
zt~+T2vIkm9d`KNKh=$)}9W01y@|tM1lRqnK1`MKTYf}K<w$CWRW0}ri`=2|(fG&Wn
z?{tMGGv2#OAixz|TT@P)U_cjO0DSwfu7>0<<K9{hI3Jovply%=2rS+lr(OYj)c$@n
z6AV|&U;ySJSHZzyjOeRLe&g7|5N7J&RNBu0e21{63g)dg8LUW$hUlkM!w?Nc+gt@+
zQ#SbO;)%qIhpq)eMg<o$M<#ZHZWcsqg3lf&n-G##0X--o;t=Of+cp2}6NF61VS+tC
zfRLaXFKF=MPBADhYShj_$P8`!vdu-@`l00@<ZuHK_F^G`M>jjbVW=~gMt;m0(mVSk
z1zffWS!^yqyqN|Ez_TNOMfWJ0g!~{zkZ%0NLFR?AA=xnW>IMME(XLSxIkC3}amGzw
zVzXyez{H`wK6n(RakTUCzHFo8Sd+fQR>P=(ae}8lP$gLau=$vG4no;RUq~!U_dUR`
zEKVR5^SS8SF_>?9a8c-|2z*dfK^}-0FBX!CZg~u^`A45TW+j5!#85J^FDA@wC<kyB
zgrS;K1yY2%&k<wfgm#{=(j<&`-LC==GHSgOl_LN~y#N3Nw-f?Z0oI6}sDKAR7>1s(
zGXU8$q6i@fP1A&!FEAVkLB~G?u@_(+#8%|<00`KS-q{7<N)`ZeFjKgY75diJfh>_T
ztxK51dndMjn+HG;M|U20F92kcZO$3O;o@6P*1tlenU!A1(rIY`6$>h8xjz8pT)xXI
zID{+)hT;{jVrrUt6RKK}v)wua0)XK+ci9)qDL-AJK!w<f0M$BiB?dvP@8IB@g8^{t
z@0x{gvxTT$U3OmB3)ozV2*Eh12R@VmAQ49KrY1BY;He=jL0~I_gW1fd%ULY@d`6_|
zJwi4Qm|Kf1@^@I(Mo@yll$Dpf-nmAS)mWAW6Z=D^g+m6a1JJ~UP-(FRSFQ!$EZo4d
zEA>Eq5GqggN;DU2iT*Eq1Oz}ss&%%OABLgt`$Px6e+jtGaM^O(LlR7)T+e5fMQlQ8
zat!$!Jrd98F;k%NKlpB31tp~EAdjK~7bum(c|Anzuj&wGGAF9Ypl^RmuOMV@k=&Q5
zXX?8WrCKIuf<%2;1m^<)LI648ms_kE#g3f&a6K0-yFfwYTpcwgG#3>0g&tM5&q6b@
zn7fdT^d-ufaxs<_6F!p_gBk_kimbjlUCO_KO?aHxsDj)P$h{dC5H#kBX)J4S+l&J2
zutt7d6W3123IWq5%*TX|l?I`}J{&MLJsfO1C^$lnz_If*CMd`Bec@nrc3YB%69rt#
z*`Do6)K0nca28zrtx1cQLqdT<%%~lcEC<sr%fB3K&S=TXxIpooWjPT)@2Bc*sRz(`
zNjb@s0MrjzaSRFq!kmfp2$-=;CuoxFp8S9~RfiWl?@`2GU}p8OsH;T|g5;-6(;<(a
z`VkHdNH`#<Z?9vEA+<})Lz3MfGhoEc*Mx7-tPxgNWaEfTkFuk_2>`kc*n$q0i5ljV
zf;fs;7UdkUBh(sWQrI{IgI|8*)Hv(b$!{Jod5pS0c8AarKMan{m}I-Vm{gdssZ1ip
znPrvY;#p=^pPn>}yJB(FH@9ZaM{7sj(t~=*Dz9>tx0f2!r<}<8&Z!&9G>c<K-I#Lu
zmcurT0=^<m3P4;~5+=b8*NE|2ILhJb&*V^{<$I1hvG+K-k|!nfdkTOp#c(xn;0*us
z8QI6jy2I~|0cAR!&1Nh7hdg0daOGM0uuAd>v5*PGX*E#ok|k^0;nXgDXfAn%@j_K6
zlZmP>7V8apVlCez9`c8UC;$`|2ILl7KUKn;vTk|eEPhrl^Vs4gJ+ZTlAG<rNVkjKQ
zZ(6YlZMRH0RiIua*8u5p71>F#G8@qc{Vr>N53uq8*oMg%kCrmA4w*$hU+q$)2Zkh^
z08X*=pC1js3_DpDAxK8hBnp*U?By<B)rbFW@5;LywShPi0Zd>W10hN<@Vb7ivvIoJ
zBYU<@zyHVT%y3B@27}Y3@2&o@h2bUhW2Dg>n$hbOjRi3x(z?068<Wp2#4EX;;h0@E
zed$=e^zRjOrr0z$Fm`UY;|qg`tEwp4Ndu_qUD+!U^U~7T@88NR+U1x8ri%@be^R})
zo4l@A)-!<KjIxbYd$!nw2a5ujAn#;dbSV8H+iXuS(?x|1F~_xw`uqF)ZylRS8~!<k
z{!d>Y%SAzP_iakj`n8FR>l<xCwK{RLx+t@Zo7T(cFQ5N@{&3&gKdpLrrC4*NQfChb
z#X+%OxdS;^+3n@Tg3#jXx32Mz8~dnz|MTOA-|zb)#SaI`;q=(}v2;+>8}NJN(8cuf
zu|~q)9CM+775x3n$37WUdgI6dEKQKoNm9GrFYcryrmoR{Ik_IU2wA73m)~;3(;{t_
zklYD4dT?c<Ncz*$(+`TOylzZ^?p*FU73%DulYTX=O!l<M45&jS=<Fja@9R6Vs2<-+
z`?AYrtS5)#;(AVvz$hN1zoDi|45${c1IW%Ij+^^=8@AH+NFLU_I+Iq~Ww)#Ezsfvs
zF`yKnPwz_dl}JxRldF<hH|p@8Rq4}b9rXXB2Et@tot$~KuLRJcj;1_4WS!g1<R-a?
zvdz3&tFG6fYCbmtdGZL7wTN~A<<ryq$8NW%y8f@vMStfMe*UAUc7dAqpvE}!XfFEE
zdVE^lMKR{muZ8U?+)A&NgRYWvZD?=@ITqdFkmyRto&Ekb!yKkxR#c_bz5T;MjY4Pr
zuAEklmE1`>pMH%y4f0t#y;<`1$^)pL0EZv%k5S)QVue_6N;S8>MW8`{?A<lXCQFNe
zEP=|1!~q@1$K7bneBzP?r`6Nz9zlBJ{d<<yL?D}L|I~z%wsXkc-^2SYI}DM{k;*aS
zWso|8SYlD>Km|b^F_V*rK?04VzH1622i)!I4CTVrDZmn=UHq`t<K)Dj{o~h>)c2NG
zxjIL=b4wmVLFjgrZ>(kLH#tDIf4v{O1^o6U&l~Y87Q{N2Du=Aw?$WWz&#f77`GWLo
zZkVscaT;3k&vgm(=Qs0qTV~fUd|C?k0>??CX0hS|LCt`v8;&<O+6y;faog%B!ngh(
z44~sx;MP*vhN%PS3~SYN&TQAxriqDJ8`nSc1T%422b`wuc0I8kzAy|D<Su<zpCZ3y
z6ug9A46S|)zHQs+`HM-fH+tk=<J0K3Jlz9fBDkr;k{arI<hqe=qIkDW-7Mscuj?Mo
zS$F_fUMn#@ue)HnsLaht`;AYoKaIv!gp}=esilFbXu2+_`=&uE1LKwc8CZoL7ucGJ
z0GsD^^T0A^458C2fFl4P35_gW0>FF%;4}c>({Ri3LOo4Pd%)oQb~1noz8?H<aUz-k
z@S+0%4UYs~a+n5TAArhdadO(p6kiX$E?_|u0KDfm072de7;2H3L}t$rg2}H>T8F3k
zdUAdzEdV>+Xalg)9b@>Tm3V!VSSxXkEF>>^$|u>nIe@@!0bqU`0Q{osyEr^5Mr%oW
zN&;xMp6KcX01UL_q&bP<(r*EPhmr^%8D}(~AV;Tr$^n3rIJ>}OGJx0wTwW6Z++aS;
z&|v7ujM8s3x{UdZbM6oT2Z|k)15rd=PyxWRfsHKlM;e{uQdqNDCk+yS+{97<<a5K}
z1`k7{001vPwe1w={D9vgpT%+f*YFv0+03&Z2|(^@Qvl=<0K^uf*dzcjH(3xclu$!|
zH7zX8p;P`cI&D+T1(5Sx1wb@7JXbLYK<y852G5Pj2N7V$Q#!L_+Z*N@?>PYCxe9=0
zVgW!902_3pRM%5Rf^?MO57@=k<?Xub{D^FQyS<yQ`R4%WjWqyZ6b1mmOg7CFY4LHM
z8wPq+ydjw<TtC?5V-2@g(D~R|6~F}IH>>U4Sv)5N01R0)0B9jDy1Z15P2^HiEK{j9
z#_&(|LR<;lZM3~!;qI@^?d|Fsh(DLrWe1F8B@Y+^U<?5;7LfxBZW)Qgu%+Bend6hf
z?=Xjt@xEB~To=TNS6A3xxuV!db&h6m&hh`a@GUf(b6W`fByf1kfKO-^JxMR#DmzPT
z^k%BplW#W@<+V`vq5W#-@Y8ai8mh{E(QK43c5y+&%gCRiaU=JCezQ%+iYW?$wCD$+
z(0E#0IAF_LUU5semHq-+9c}bPB`;yga_cBw>`PJYNa`m`000s_0MjZZ`-|<ENqxsg
zr6GkICM<6u!h}26_t1G!_T6OwFb#p44go+F$7cnA2xJW|#snZY1^_@r1~e{v%K?De
zer&o00A2$iZ6YQBsMADVXcua!2(iB$06g+-tp`BG0nIHf8@uQ)2SBd6pyp#3VJ8Qe
znM8;Z0aX2E0l*=I%CfU-alkKRRUB}ozdQ~UEwxk*SbAIuTdBXGNlf|=0EiKTllq#<
z0bzwnLZZ`jwW>d8R{n<o{G^z~QEt{~DhCRGp;tMCsJ|otwHQryWZtM8uz1Lehuyp{
zmIT1nq=gKfDFCSiU?2xvkHvU_9I(u)zZ3we&$(Bx#0mMO5r79~3);0IUg*$I5kTEv
z1ORyTF{+lxh#Ua2Kqo0gI%kX=Aa6T91k9293jn~&SPBcvl^8LFT2!m1wpQ&jc0#4U
zfadz1j?D}Wjq4QBvrRosU_mzNhVJ2%E-vsXx&Nz;YySdijLQQ<U0ALF0000<MNUMn
GLSTZ8pMJpr

literal 0
HcmV?d00001

diff --git a/public/reset-password.html b/public/reset-password.html
new file mode 100644
index 0000000..32f4c12
--- /dev/null
+++ b/public/reset-password.html
@@ -0,0 +1,81 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Passwort zurücksetzen - NinjaCross</title>
+    <link rel="icon" type="image/x-icon" href="/pictures/favicon.ico">
+    
+    <!-- Supabase -->
+    <script src="https://cdn.jsdelivr.net/npm/@supabase/supabase-js@2"></script>
+    
+    <link rel="stylesheet" href="/css/reset-password.css">
+</head>
+<body>
+    <div class="container">
+        <div class="logo">🥷 NINJACROSS</div>
+        <div class="tagline">Die ultimative Timer-Rangliste</div>
+        
+        <h1 class="title">Passwort zurücksetzen 🔐</h1>
+        <p class="subtitle">Gib dein neues Passwort ein, um dein Konto zu sichern</p>
+        
+        <div id="messageContainer"></div>
+        
+        <form id="resetForm">
+            <div class="form-group">
+                <label for="newPassword" class="form-label">Neues Passwort</label>
+                <input 
+                    type="password" 
+                    id="newPassword" 
+                    name="newPassword" 
+                    class="form-input" 
+                    placeholder="Mindestens 8 Zeichen"
+                    required
+                    minlength="8"
+                >
+            </div>
+            
+            <div class="form-group">
+                <label for="confirmPassword" class="form-label">Passwort bestätigen</label>
+                <input 
+                    type="password" 
+                    id="confirmPassword" 
+                    name="confirmPassword" 
+                    class="form-input" 
+                    placeholder="Passwort wiederholen"
+                    required
+                    minlength="8"
+                >
+            </div>
+            
+            <button type="submit" class="btn btn-primary" id="resetBtn">
+                🔄 Passwort zurücksetzen
+            </button>
+        </form>
+        
+        <div class="loading" id="loading">
+            <div class="spinner"></div>
+            Passwort wird zurückgesetzt...
+        </div>
+        
+        <a href="/" class="back-link">← Zurück zur Hauptseite</a>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-content">
+            <div class="footer-links">
+                <a href="/impressum.html" class="footer-link">Impressum</a>
+                <a href="/datenschutz.html" class="footer-link">Datenschutz</a>
+                <button id="cookie-settings-footer" class="footer-link cookie-settings-btn">Cookie-Einstellungen</button>
+            </div>
+            <div class="footer-text">
+                <p>&copy; 2024 NinjaCross. Alle Rechte vorbehalten.</p>
+            </div>
+        </div>
+    </footer>
+
+    <script src="/js/cookie-consent.js"></script>
+    <script src="/js/reset-password.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/public/sw.js b/public/sw.js
new file mode 100644
index 0000000..cbf68d6
--- /dev/null
+++ b/public/sw.js
@@ -0,0 +1,137 @@
+// Service Worker für iPhone Notifications
+const CACHE_NAME = 'ninjacross-v1';
+const urlsToCache = [
+    '/',
+    '/test-push.html',
+    '/sw.js'
+];
+
+// Install event
+self.addEventListener('install', function(event) {
+    console.log('Service Worker installing...');
+    event.waitUntil(
+        caches.open(CACHE_NAME)
+            .then(function(cache) {
+                // Add files one by one to handle failures gracefully
+                return Promise.allSettled(
+                    urlsToCache.map(url => 
+                        cache.add(url).catch(err => {
+                            console.warn(`Failed to cache ${url}:`, err);
+                            return null; // Continue with other files
+                        })
+                    )
+                );
+            })
+            .then(() => {
+                console.log('Service Worker installation completed');
+                // Skip waiting to activate immediately
+                return self.skipWaiting();
+            })
+            .catch(err => {
+                console.error('Service Worker installation failed:', err);
+                // Still try to skip waiting
+                return self.skipWaiting();
+            })
+    );
+});
+
+// Activate event
+self.addEventListener('activate', function(event) {
+    console.log('Service Worker activating...');
+    event.waitUntil(
+        caches.keys().then(function(cacheNames) {
+            return Promise.all(
+                cacheNames.map(function(cacheName) {
+                    if (cacheName !== CACHE_NAME) {
+                        return caches.delete(cacheName);
+                    }
+                })
+            );
+        }).then(() => {
+            // Take control of all clients immediately
+            return self.clients.claim();
+        })
+    );
+});
+
+// Listen for skip waiting message
+self.addEventListener('message', function(event) {
+    if (event.data && event.data.type === 'SKIP_WAITING') {
+        self.skipWaiting();
+    }
+});
+
+// Fetch event
+self.addEventListener('fetch', function(event) {
+    event.respondWith(
+        caches.match(event.request)
+            .then(function(response) {
+                // Return cached version or fetch from network
+                return response || fetch(event.request);
+            }
+        )
+    );
+});
+
+// Push event (für iPhone Notifications)
+self.addEventListener('push', function(event) {
+    console.log('Push received:', event);
+    
+    const options = {
+        body: 'Du hast eine neue Notification!',
+        icon: '/pictures/icon-192.png',
+        badge: '/pictures/icon-192.png',
+        vibrate: [100, 50, 100],
+        data: {
+            dateOfArrival: Date.now(),
+            primaryKey: 1
+        },
+        actions: [
+            {
+                action: 'explore',
+                title: 'Dashboard öffnen',
+                icon: '/pictures/icon-192.png'
+            },
+            {
+                action: 'close',
+                title: 'Schließen',
+                icon: '/pictures/icon-192.png'
+            }
+        ]
+    };
+    
+    if (event.data) {
+        const data = event.data.json();
+        options.body = data.body || options.body;
+        options.title = data.title || 'Ninja Cross';
+    }
+    
+    event.waitUntil(
+        self.registration.showNotification('Ninja Cross', options)
+    );
+});
+
+// Notification click event
+self.addEventListener('notificationclick', function(event) {
+    console.log('Notification clicked:', event);
+    
+    event.notification.close();
+    
+    if (event.action === 'explore') {
+        event.waitUntil(
+            clients.openWindow('/dashboard.html')
+        );
+    }
+});
+
+// Background sync (für offline functionality)
+self.addEventListener('sync', function(event) {
+    if (event.tag === 'background-sync') {
+        event.waitUntil(doBackgroundSync());
+    }
+});
+
+async function doBackgroundSync() {
+    // Sync data when back online
+    console.log('Background sync triggered');
+}
diff --git a/public/test-push.html b/public/test-push.html
new file mode 100644
index 0000000..78dfdf1
--- /dev/null
+++ b/public/test-push.html
@@ -0,0 +1,560 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Push Notification Test - Ninja Cross</title>
+    <link rel="icon" type="image/x-icon" href="/pictures/favicon.ico">
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            min-height: 100vh;
+        }
+        .container {
+            background: rgba(255, 255, 255, 0.1);
+            padding: 30px;
+            border-radius: 15px;
+            backdrop-filter: blur(10px);
+        }
+        h1 {
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        .status {
+            background: rgba(0, 0, 0, 0.2);
+            padding: 15px;
+            border-radius: 10px;
+            margin: 20px 0;
+        }
+        .status.success { background: rgba(34, 197, 94, 0.3); }
+        .status.error { background: rgba(239, 68, 68, 0.3); }
+        .status.warning { background: rgba(245, 158, 11, 0.3); }
+        button {
+            background: linear-gradient(135deg, #00d4ff, #0891b2);
+            color: white;
+            border: none;
+            padding: 12px 24px;
+            border-radius: 8px;
+            cursor: pointer;
+            font-size: 16px;
+            margin: 10px 5px;
+            transition: transform 0.2s;
+        }
+        button:hover {
+            transform: translateY(-2px);
+        }
+        button:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+            transform: none;
+        }
+        input, textarea {
+            width: 100%;
+            padding: 10px;
+            border: none;
+            border-radius: 5px;
+            margin: 10px 0;
+            font-size: 16px;
+        }
+        .log {
+            background: rgba(0, 0, 0, 0.3);
+            padding: 15px;
+            border-radius: 10px;
+            margin-top: 20px;
+            max-height: 300px;
+            overflow-y: auto;
+            font-family: monospace;
+            font-size: 14px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🧪 Push Notification Test</h1>
+        
+        <div id="status" class="status">
+            <strong>Status:</strong> <span id="statusText">Lädt...</span>
+        </div>
+        
+        <div>
+            <h3>1. Service Worker Status</h3>
+            <button onclick="checkServiceWorker()">Service Worker prüfen</button>
+            <button onclick="registerServiceWorker()">Service Worker registrieren</button>
+        </div>
+        
+        <div>
+            <h3>2. Notification Permission</h3>
+            <button onclick="requestPermission()">Berechtigung anfordern</button>
+            <button onclick="checkPermission()">Berechtigung prüfen</button>
+        </div>
+        
+        <div>
+            <h3>3. Push Subscription</h3>
+            <button onclick="subscribeToPush()">Push abonnieren</button>
+            <button onclick="unsubscribeFromPush()">Push abbestellen</button>
+            <button onclick="checkSubscription()">Subscription prüfen</button>
+        </div>
+        
+        <div>
+            <h3>4. Test Notifications</h3>
+            <input type="text" id="testMessage" placeholder="Test-Nachricht" value="Das ist eine Test-Push-Notification!">
+            <button onclick="sendTestPush()">Test-Push senden</button>
+            <button onclick="sendTestWebNotification()">Web-Notification senden</button>
+            <button onclick="sendWindowsNotification()">Windows-Notification senden</button>
+        </div>
+        
+        <div>
+            <h3>5. Push Status</h3>
+            <button onclick="getPushStatus()">Push-Status abrufen</button>
+        </div>
+        
+        <div class="log" id="log">
+            <div>Log wird hier angezeigt...</div>
+        </div>
+    </div>
+
+    <script>
+        let currentSubscription = null;
+        
+        // Convert VAPID key from base64url to Uint8Array
+        function urlBase64ToUint8Array(base64String) {
+            const padding = '='.repeat((4 - base64String.length % 4) % 4);
+            const base64 = (base64String + padding)
+                .replace(/\-/g, '+')
+                .replace(/_/g, '/');
+            
+            const rawData = window.atob(base64);
+            const outputArray = new Uint8Array(rawData.length);
+            
+            for (let i = 0; i < rawData.length; ++i) {
+                outputArray[i] = rawData.charCodeAt(i);
+            }
+            return outputArray;
+        }
+        
+        function log(message, type = 'info') {
+            const logDiv = document.getElementById('log');
+            const timestamp = new Date().toLocaleTimeString();
+            const logEntry = document.createElement('div');
+            logEntry.style.color = type === 'error' ? '#ff6b6b' : type === 'success' ? '#51cf66' : '#ffffff';
+            logEntry.textContent = `[${timestamp}] ${message}`;
+            logDiv.appendChild(logEntry);
+            logDiv.scrollTop = logDiv.scrollHeight;
+        }
+        
+        function updateStatus(message, type = 'info') {
+            const statusDiv = document.getElementById('status');
+            const statusText = document.getElementById('statusText');
+            statusText.textContent = message;
+            statusDiv.className = `status ${type}`;
+        }
+        
+        // Service Worker Functions
+        async function checkServiceWorker() {
+            if ('serviceWorker' in navigator) {
+                const registrations = await navigator.serviceWorker.getRegistrations();
+                log(`Service Worker registriert: ${registrations.length > 0 ? 'Ja' : 'Nein'}`);
+                if (registrations.length > 0) {
+                    const reg = registrations[0];
+                    log(`SW Scope: ${reg.scope}`);
+                    log(`SW State: ${reg.active ? reg.active.state : 'kein aktiver Worker'}`);
+                }
+            } else {
+                log('Service Worker nicht unterstützt', 'error');
+            }
+        }
+        
+        async function registerServiceWorker() {
+            if ('serviceWorker' in navigator) {
+                try {
+                    log('Service Worker wird registriert...', 'info');
+                    const registration = await navigator.serviceWorker.register('/sw.js');
+                    log('Service Worker erfolgreich registriert', 'success');
+                    log(`SW Scope: ${registration.scope}`);
+                    updateStatus('Service Worker registriert', 'success');
+                } catch (error) {
+                    log(`Service Worker Registrierung fehlgeschlagen: ${error.message}`, 'error');
+                    log(`Error Details: ${JSON.stringify(error)}`, 'error');
+                    updateStatus(`Service Worker Registrierung fehlgeschlagen: ${error.message}`, 'error');
+                }
+            } else {
+                log('Service Worker nicht unterstützt', 'error');
+                updateStatus('Service Worker nicht unterstützt', 'error');
+            }
+        }
+        
+        // Notification Permission Functions
+        async function requestPermission() {
+            if ('Notification' in window) {
+                const permission = await Notification.requestPermission();
+                log(`Notification Permission: ${permission}`, permission === 'granted' ? 'success' : 'warning');
+                updateStatus(`Notification Permission: ${permission}`, permission === 'granted' ? 'success' : 'warning');
+            } else {
+                log('Notifications nicht unterstützt', 'error');
+            }
+        }
+        
+        function checkPermission() {
+            if ('Notification' in window) {
+                log(`Notification Permission: ${Notification.permission}`);
+                updateStatus(`Notification Permission: ${Notification.permission}`, 
+                    Notification.permission === 'granted' ? 'success' : 'warning');
+            } else {
+                log('Notifications nicht unterstützt', 'error');
+            }
+        }
+        
+        // Push Subscription Functions
+        async function subscribeToPush() {
+            log('Push Subscription gestartet...', 'info');
+            
+            // Check basic requirements
+            if (!('serviceWorker' in navigator)) {
+                log('Service Worker nicht unterstützt', 'error');
+                updateStatus('Service Worker nicht unterstützt', 'error');
+                return;
+            }
+            
+            if (!('PushManager' in window)) {
+                log('Push Manager nicht unterstützt', 'error');
+                updateStatus('Push Manager nicht unterstützt', 'error');
+                return;
+            }
+            
+            // Check notification permission first
+            if (Notification.permission !== 'granted') {
+                log('Notification Permission nicht erteilt. Bitte zuerst "Berechtigung anfordern" klicken!', 'error');
+                updateStatus('Notification Permission erforderlich', 'error');
+                return;
+            }
+            
+            try {
+                log('Service Worker wird geladen...', 'info');
+                
+                // First check if service worker is already registered
+                let registration;
+                const existingRegistrations = await navigator.serviceWorker.getRegistrations();
+                
+                if (existingRegistrations.length > 0) {
+                    log('Service Worker bereits registriert, verwende bestehende...', 'info');
+                    registration = existingRegistrations[0];
+                } else {
+                    log('Service Worker nicht registriert, registriere jetzt...', 'info');
+                    registration = await navigator.serviceWorker.register('/sw.js');
+                    log('Service Worker registriert', 'success');
+                }
+                
+                // Wait for service worker to be ready with timeout
+                log('Warte auf Service Worker ready...', 'info');
+                
+                // Check if service worker is active
+                if (registration.active) {
+                    log('Service Worker ist bereits aktiv', 'success');
+                } else if (registration.installing && registration.installing.state) {
+                    log('Service Worker wird installiert, warte...', 'info');
+                    await new Promise((resolve) => {
+                        const installingWorker = registration.installing;
+                        if (installingWorker) {
+                            installingWorker.addEventListener('statechange', () => {
+                                if (installingWorker.state === 'installed') {
+                                    resolve();
+                                }
+                            });
+                        } else {
+                            resolve();
+                        }
+                    });
+                    log('Service Worker Installation abgeschlossen', 'success');
+                } else if (registration.waiting && registration.waiting.state) {
+                    log('Service Worker wartet, aktiviere...', 'info');
+                    registration.waiting.postMessage({ type: 'SKIP_WAITING' });
+                    await new Promise((resolve) => {
+                        const waitingWorker = registration.waiting;
+                        if (waitingWorker) {
+                            waitingWorker.addEventListener('statechange', () => {
+                                if (waitingWorker.state === 'activated') {
+                                    resolve();
+                                }
+                            });
+                        } else {
+                            resolve();
+                        }
+                    });
+                    log('Service Worker aktiviert', 'success');
+                } else {
+                    log('Service Worker Status unbekannt, warte auf ready...', 'info');
+                    try {
+                        await navigator.serviceWorker.ready;
+                        log('Service Worker bereit', 'success');
+                    } catch (error) {
+                        log(`Service Worker ready fehlgeschlagen: ${error.message}`, 'error');
+                        throw error;
+                    }
+                }
+                
+                // Convert VAPID key from base64url to ArrayBuffer
+                const vapidPublicKey = 'BJmNVx0C3XeVxeKGTP9c-Z4HcuZNmdk6QdiLocZgCmb-miCS0ESFO3W2TvJlRhhNAShV63pWA5p36BTVSetyTds';
+                log('VAPID Key wird konvertiert...', 'info');
+                
+                let applicationServerKey;
+                try {
+                    applicationServerKey = urlBase64ToUint8Array(vapidPublicKey);
+                    log('VAPID Key konvertiert', 'success');
+                } catch (error) {
+                    log(`VAPID Key Konvertierung fehlgeschlagen: ${error.message}`, 'error');
+                    throw error;
+                }
+                
+                log('Push Subscription wird erstellt...', 'info');
+                
+                // Check if push manager is available
+                if (!registration.pushManager) {
+                    throw new Error('Push Manager nicht verfügbar in diesem Service Worker');
+                }
+                
+                const subscription = await registration.pushManager.subscribe({
+                    userVisibleOnly: true,
+                    applicationServerKey: applicationServerKey
+                });
+                
+                currentSubscription = subscription;
+                log('Push Subscription erfolgreich erstellt', 'success');
+                log(`Endpoint: ${subscription.endpoint.substring(0, 50)}...`);
+                
+                // Send to server
+                log('Subscription wird an Server gesendet...', 'info');
+                const response = await fetch('/api/v1/public/subscribe', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify(subscription)
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                
+                const result = await response.json();
+                if (result.success) {
+                    log('Subscription erfolgreich an Server gesendet', 'success');
+                    log(`Player ID: ${result.playerId || 'anonymous'}`, 'success');
+                    
+                    // Store the player ID for later use
+                    if (result.playerId) {
+                        localStorage.setItem('pushPlayerId', result.playerId);
+                    }
+                    
+                    updateStatus('Push Subscription erfolgreich!', 'success');
+                    // Store the subscription endpoint for later use
+                    localStorage.setItem('pushSubscriptionEndpoint', subscription.endpoint);
+                } else {
+                    log(`Server-Fehler: ${result.message}`, 'error');
+                    updateStatus(`Server-Fehler: ${result.message}`, 'error');
+                }
+                
+            } catch (error) {
+                log(`Push Subscription fehlgeschlagen: ${error.message}`, 'error');
+                log(`Error Details: ${JSON.stringify(error)}`, 'error');
+                updateStatus(`Push Subscription fehlgeschlagen: ${error.message}`, 'error');
+            }
+        }
+        
+        async function unsubscribeFromPush() {
+            if (currentSubscription) {
+                try {
+                    await currentSubscription.unsubscribe();
+                    currentSubscription = null;
+                    log('Push Subscription erfolgreich abbestellt', 'success');
+                } catch (error) {
+                    log(`Push Unsubscribe fehlgeschlagen: ${error.message}`, 'error');
+                }
+            } else {
+                log('Keine aktive Subscription gefunden', 'warning');
+            }
+        }
+        
+        async function checkSubscription() {
+            log('Überprüfe Push Subscription...', 'info');
+            
+            if (!('serviceWorker' in navigator)) {
+                log('Service Worker nicht unterstützt', 'error');
+                return;
+            }
+            
+            try {
+                const registration = await navigator.serviceWorker.ready;
+                const subscription = await registration.pushManager.getSubscription();
+                
+                if (subscription) {
+                    currentSubscription = subscription;
+                    log('Aktive Push Subscription gefunden', 'success');
+                    log(`Endpoint: ${subscription.endpoint.substring(0, 50)}...`);
+                    updateStatus('Push Subscription aktiv', 'success');
+                } else {
+                    log('Keine Push Subscription gefunden', 'warning');
+                    updateStatus('Keine Push Subscription gefunden', 'warning');
+                }
+            } catch (error) {
+                log(`Subscription Check fehlgeschlagen: ${error.message}`, 'error');
+                updateStatus(`Subscription Check fehlgeschlagen: ${error.message}`, 'error');
+            }
+        }
+        
+        // Test Functions
+        async function sendTestPush() {
+            const message = document.getElementById('testMessage').value;
+            log('Test-Push wird gesendet...', 'info');
+            
+            // First check if we have a subscription
+            if (!currentSubscription) {
+                log('Keine Push Subscription gefunden. Bitte zuerst "Push abonnieren" klicken!', 'error');
+                updateStatus('Keine Push Subscription gefunden', 'error');
+                return;
+            }
+            
+            // Use the stored player ID from subscription
+            const storedPlayerId = localStorage.getItem('pushPlayerId');
+            let userId = 'test-user';
+            if (storedPlayerId) {
+                userId = storedPlayerId;
+            }
+            
+            log(`Sende Test-Push an Player ID: ${userId}`, 'info');
+            
+            try {
+                const response = await fetch('/api/v1/public/test-push', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        userId: userId,
+                        message: message
+                    })
+                });
+                
+                const result = await response.json();
+                if (result.success) {
+                    log('Test-Push erfolgreich gesendet', 'success');
+                    log(`An User ID: ${userId}`, 'success');
+                    updateStatus('Test-Push erfolgreich gesendet!', 'success');
+                } else {
+                    log(`Test-Push fehlgeschlagen: ${result.message}`, 'error');
+                    updateStatus(`Test-Push fehlgeschlagen: ${result.message}`, 'error');
+                }
+            } catch (error) {
+                log(`Test-Push Fehler: ${error.message}`, 'error');
+                updateStatus(`Test-Push Fehler: ${error.message}`, 'error');
+            }
+        }
+        
+        function sendTestWebNotification() {
+            if ('Notification' in window && Notification.permission === 'granted') {
+                const message = document.getElementById('testMessage').value;
+                const notification = new Notification('🧪 Test Web Notification', {
+                    body: message,
+                    icon: '/pictures/icon-192.png',
+                    badge: '/pictures/icon-192.png',
+                    tag: 'test-notification',
+                    requireInteraction: true,
+                    silent: false
+                });
+                
+                notification.onclick = function() {
+                    window.focus();
+                    notification.close();
+                };
+                
+                // Auto-close after 10 seconds
+                setTimeout(() => {
+                    notification.close();
+                }, 10000);
+                
+                log('Web-Notification gesendet', 'success');
+            } else {
+                log('Web-Notifications nicht verfügbar oder nicht erlaubt', 'error');
+            }
+        }
+        
+        // Windows Desktop Notification (falls verfügbar)
+        function sendWindowsNotification() {
+            if ('Notification' in window && Notification.permission === 'granted') {
+                const message = document.getElementById('testMessage').value;
+                
+                // Erstelle eine Windows-ähnliche Notification
+                const notification = new Notification('🏆 Ninja Cross - Achievement!', {
+                    body: message,
+                    icon: '/pictures/icon-192.png',
+                    badge: '/pictures/icon-192.png',
+                    tag: 'ninja-cross-achievement',
+                    requireInteraction: true,
+                    silent: false,
+                    data: {
+                        type: 'achievement',
+                        timestamp: Date.now()
+                    }
+                });
+                
+                notification.onclick = function() {
+                    window.focus();
+                    notification.close();
+                };
+                
+                // Auto-close after 15 seconds
+                setTimeout(() => {
+                    notification.close();
+                }, 15000);
+                
+                log('Windows-ähnliche Notification gesendet', 'success');
+            } else {
+                log('Web-Notifications nicht verfügbar oder nicht erlaubt', 'error');
+            }
+        }
+        
+        async function getPushStatus() {
+            try {
+                const response = await fetch('/api/v1/public/push-status');
+                const result = await response.json();
+                
+                if (result.success) {
+                    log(`Push Status: ${JSON.stringify(result.data, null, 2)}`, 'success');
+                } else {
+                    log(`Push Status Fehler: ${result.message}`, 'error');
+                }
+            } catch (error) {
+                log(`Push Status Fehler: ${error.message}`, 'error');
+            }
+        }
+        
+        // Initialize
+        window.addEventListener('load', function() {
+            console.log('Push Notification Test Seite geladen');
+            log('Push Notification Test Seite geladen');
+            
+            // Check if we're on HTTPS
+            if (location.protocol !== 'https:' && location.hostname !== 'localhost') {
+                log('WARNUNG: Push Notifications funktionieren nur über HTTPS!', 'error');
+                updateStatus('HTTPS erforderlich für Push Notifications', 'error');
+            } else {
+                log('HTTPS-Verbindung erkannt - Push Notifications möglich', 'success');
+            }
+            
+            checkServiceWorker();
+            checkPermission();
+            checkSubscription();
+        });
+        
+        // Also initialize on DOMContentLoaded as backup
+        document.addEventListener('DOMContentLoaded', function() {
+            console.log('DOM Content Loaded');
+            log('DOM Content Loaded - Initialisierung gestartet');
+        });
+    </script>
+</body>
+</html>
diff --git a/routes/api.js b/routes/api.js
new file mode 100644
index 0000000..ece732f
--- /dev/null
+++ b/routes/api.js
@@ -0,0 +1,4969 @@
+// routes/api.js
+const express = require('express');
+const { Pool } = require('pg');
+const bcrypt = require('bcrypt');
+const { start } = require('repl');
+const pushService = require('../lib/push-service');
+const router = express.Router();
+
+// PostgreSQL Pool mit .env Konfiguration
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    database: process.env.DB_NAME,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    ssl: process.env.DB_SSL === 'true' ? { rejectUnauthorized: false } : false
+});
+
+// Fehlerbehandlung für Pool
+pool.on('error', (err) => {
+    console.error('PostgreSQL Pool Fehler:', err);
+});
+
+// Helper function to convert time string to seconds
+function convertTimeToSeconds(timeStr) {
+    if (!timeStr) return 0;
+
+    // Handle different time formats
+    if (typeof timeStr === 'string') {
+        // Handle MM:SS.mmm format
+        if (/^\d{1,2}:\d{2}\.\d{3}$/.test(timeStr)) {
+            const [minutes, secondsWithMs] = timeStr.split(':');
+            const [seconds, milliseconds] = secondsWithMs.split('.');
+            return parseInt(minutes) * 60 + parseInt(seconds) + parseInt(milliseconds) / 1000;
+        }
+
+        // Handle HH:MM:SS.mmm format
+        if (/^\d{1,2}:\d{2}:\d{2}\.\d{3}$/.test(timeStr)) {
+            const [hours, minutes, secondsWithMs] = timeStr.split(':');
+            const [seconds, milliseconds] = secondsWithMs.split('.');
+            return parseInt(hours) * 3600 + parseInt(minutes) * 60 + parseInt(seconds) + parseInt(milliseconds) / 1000;
+        }
+
+        // Handle HH:MM:SS format
+        if (/^\d{1,2}:\d{2}:\d{2}$/.test(timeStr)) {
+            const [hours, minutes, seconds] = timeStr.split(':');
+            return parseInt(hours) * 3600 + parseInt(minutes) * 60 + parseInt(seconds);
+        }
+
+        // Handle MM:SS format
+        if (/^\d{1,2}:\d{2}$/.test(timeStr)) {
+            const [minutes, seconds] = timeStr.split(':');
+            return parseInt(minutes) * 60 + parseInt(seconds);
+        }
+    }
+
+    // If it's already a number (seconds)
+    if (typeof timeStr === 'number') {
+        return timeStr;
+    }
+
+    return 0;
+}
+
+// Helper function to convert PostgreSQL interval to seconds
+function convertIntervalToSeconds(interval) {
+    if (!interval) return 0;
+
+    // Handle PostgreSQL interval object format
+    if (typeof interval === 'object' && interval.seconds !== undefined) {
+        return parseFloat(interval.seconds);
+    }
+
+    // PostgreSQL interval format: "HH:MM:SS" or "MM:SS" or just seconds
+    if (typeof interval === 'string') {
+        const parts = interval.split(':');
+        if (parts.length === 3) {
+            // HH:MM:SS format
+            const [hours, minutes, seconds] = parts;
+            return parseInt(hours) * 3600 + parseInt(minutes) * 60 + parseFloat(seconds);
+        } else if (parts.length === 2) {
+            // MM:SS format
+            const [minutes, seconds] = parts;
+            return parseInt(minutes) * 60 + parseFloat(seconds);
+        }
+    }
+
+    // If it's already a number (seconds)
+    if (typeof interval === 'number') {
+        return interval;
+    }
+
+    return 0;
+}
+
+// Middleware für API-Key Authentifizierung
+async function requireApiKey(req, res, next) {
+    const authHeader = req.headers.authorization;
+
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        return res.status(401).json({
+            success: false,
+            message: 'API-Key erforderlich. Verwenden Sie: Authorization: Bearer YOUR_API_KEY'
+        });
+    }
+
+    const apiKey = authHeader.substring(7); // "Bearer " entfernen
+
+    try {
+        // API-Key in der Datenbank validieren
+        const result = await pool.query(
+            `SELECT id, description, standorte, created_at, expires_at, is_active 
+             FROM api_tokens 
+             WHERE token = $1 AND is_active = true`,
+            [apiKey]
+        );
+
+        if (result.rows.length === 0) {
+            return res.status(401).json({
+                success: false,
+                message: 'Ungültiger oder inaktiver API-Key'
+            });
+        }
+
+        const tokenData = result.rows[0];
+
+        // Prüfen ob Token abgelaufen ist
+        if (tokenData.expires_at && new Date() > new Date(tokenData.expires_at)) {
+            return res.status(401).json({
+                success: false,
+                message: 'API-Key ist abgelaufen'
+            });
+        }
+
+        // Token-Daten für weitere Verwendung speichern
+        req.apiToken = tokenData;
+        next();
+
+    } catch (error) {
+        console.error('Fehler bei API-Key Validierung:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler bei der API-Key Validierung'
+        });
+    }
+}
+
+// ============================================================================
+// PUBLIC API ROUTES (/api/v1/public/)
+// ============================================================================
+
+// Login-Route (bleibt für Web-Interface)
+router.post('/v1/public/login', async (req, res) => {
+    const { username, password } = req.body;
+
+    if (!username || !password) {
+        return res.status(400).json({
+            success: false,
+            message: 'Benutzername und Passwort sind erforderlich'
+        });
+    }
+
+    try {
+        const result = await pool.query(
+            'SELECT id, username, password_hash, access_level FROM adminusers WHERE username = $1 AND is_active = true',
+            [username]
+        );
+
+        if (result.rows.length === 0) {
+            return res.status(401).json({
+                success: false,
+                message: 'Ungültige Anmeldedaten'
+            });
+        }
+
+        const user = result.rows[0];
+        const isValidPassword = await bcrypt.compare(password, user.password_hash);
+
+        if (!isValidPassword) {
+            return res.status(401).json({
+                success: false,
+                message: 'Ungültige Anmeldedaten'
+            });
+        }
+
+        // Session setzen
+        req.session.userId = user.id;
+        req.session.username = user.username;
+        req.session.accessLevel = user.access_level;
+
+        // Session speichern
+        req.session.save((err) => {
+            if (err) {
+                console.error('Fehler beim Speichern der Session:', err);
+                return res.status(500).json({
+                    success: false,
+                    message: 'Fehler beim Speichern der Session'
+                });
+            }
+
+            res.json({
+                success: true,
+                message: 'Erfolgreich angemeldet',
+                user: {
+                    id: user.id,
+                    username: user.username,
+                    access_level: user.access_level
+                }
+            });
+        });
+
+    } catch (error) {
+        console.error('Fehler bei der Anmeldung:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Interner Serverfehler bei der Anmeldung'
+        });
+    }
+});
+
+// Logout-Route (bleibt für Web-Interface)
+router.post('/v1/public/logout', (req, res) => {
+    req.session.destroy((err) => {
+        if (err) {
+            return res.status(500).json({
+                success: false,
+                message: 'Fehler beim Abmelden'
+            });
+        }
+        res.json({
+            success: true,
+            message: 'Erfolgreich abgemeldet'
+        });
+    });
+});
+
+// ============================================================================
+// PRIVATE API ROUTES (/api/v1/private/)
+// ============================================================================
+
+// API Endpunkt zum Speichern der Tokens (geschützt mit API-Key)
+router.post('/v1/private/save-token', requireApiKey, async (req, res) => {
+    const { token, description, standorte } = req.body;
+
+    // Validierung
+    if (!token) {
+        return res.status(400).json({
+            success: false,
+            message: 'Token ist erforderlich'
+        });
+    }
+
+    try {
+        // Prüfen ob Token bereits existiert
+        const existingToken = await pool.query(
+            'SELECT id FROM api_tokens WHERE token = $1',
+            [token]
+        );
+
+        if (existingToken.rows.length > 0) {
+            return res.status(409).json({
+                success: false,
+                message: 'Token existiert bereits in der Datenbank'
+            });
+        }
+
+        // Token in Datenbank einfügen
+        const result = await pool.query(
+            `INSERT INTO api_tokens (token, description, standorte, expires_at) 
+             VALUES ($1, $2, $3, $4) 
+             RETURNING id, created_at`,
+            [
+                token,
+                description,
+                standorte,
+                new Date(Date.now() + 2 * 365 * 24 * 60 * 60 * 1000) // 2 Jahre gültig
+            ]
+        );
+
+
+
+        res.json({
+            success: true,
+            message: 'Token erfolgreich als API-Token gespeichert',
+            data: {
+                id: result.rows[0].id,
+                created_at: result.rows[0].created_at
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Speichern des Tokens:', error);
+
+        // Spezifische Fehlermeldungen
+        if (error.code === '23505') { // Duplicate key
+            res.status(409).json({
+                success: false,
+                message: 'Token existiert bereits'
+            });
+        } else if (error.code === 'ECONNREFUSED') {
+            res.status(503).json({
+                success: false,
+                message: 'Datenbankverbindung fehlgeschlagen'
+            });
+        } else {
+            res.status(500).json({
+                success: false,
+                message: 'Interner Serverfehler beim Speichern des Tokens'
+            });
+        }
+    }
+});
+
+// API Endpunkt zum Abrufen aller Tokens (geschützt mit API-Key)
+router.get('/v1/private/tokens', requireApiKey, async (req, res) => {
+    try {
+        const result = await pool.query(
+            `SELECT id, token, description, standorte, created_at, expires_at, is_active 
+             FROM api_tokens 
+             ORDER BY created_at DESC`
+        );
+
+        res.json({
+            success: true,
+            data: result.rows
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Abrufen der Tokens:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der Tokens'
+        });
+    }
+});
+
+// API Endpunkt zum Validieren eines Tokens (geschützt mit API-Key)
+router.post('/v1/private/validate-token', requireApiKey, async (req, res) => {
+    const { token } = req.body;
+
+    if (!token) {
+        return res.status(400).json({
+            success: false,
+            message: 'Token ist erforderlich'
+        });
+    }
+
+    try {
+        const result = await pool.query(
+            `SELECT id, description, standorte, created_at, expires_at, is_active 
+             FROM api_tokens 
+             WHERE token = $1 AND is_active = true`,
+            [token]
+        );
+
+        if (result.rows.length === 0) {
+            return res.status(401).json({
+                success: false,
+                message: 'Ungültiger oder inaktiver Token'
+            });
+        }
+
+        const tokenData = result.rows[0];
+
+        // Prüfen ob Token abgelaufen ist
+        if (tokenData.expires_at && new Date() > new Date(tokenData.expires_at)) {
+            return res.status(401).json({
+                success: false,
+                message: 'Token ist abgelaufen'
+            });
+        }
+
+        res.json({
+            success: true,
+            message: 'Token ist gültig',
+            data: {
+                id: tokenData.id,
+                description: tokenData.description,
+                standorte: tokenData.standorte,
+                created_at: tokenData.created_at,
+                expires_at: tokenData.expires_at
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler bei Token-Validierung:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler bei der Token-Validierung'
+        });
+    }
+});
+
+// Neue API-Route für Standortverwaltung (geschützt mit API-Key)
+router.post('/v1/private/create-location', requireApiKey, async (req, res) => {
+    const { name, lat, lon } = req.body;
+
+    // Validierung
+    if (!name || lat === undefined || lon === undefined) {
+        return res.status(400).json({
+            success: false,
+            message: 'Name, Breitengrad und Längengrad sind erforderlich'
+        });
+    }
+
+    try {
+        // Prüfen ob Standort bereits existiert
+        const existingLocation = await pool.query(
+            'SELECT id FROM locations WHERE name = $1',
+            [name]
+        );
+
+        if (existingLocation.rows.length > 0) {
+            return res.status(409).json({
+                success: false,
+                message: 'Standort existiert bereits in der Datenbank'
+            });
+        }
+
+        // Standort in Datenbank einfügen
+        const result = await pool.query(
+            `INSERT INTO locations (name, latitude, longitude, created_at) 
+             VALUES ($1, $2, $3, $4) 
+             RETURNING id, created_at`,
+            [name, lat, lon, new Date()]
+        );
+
+
+
+        res.json({
+            success: true,
+            message: 'Standort erfolgreich gespeichert',
+            data: {
+                id: result.rows[0].id,
+                name: name,
+                latitude: lat,
+                longitude: lon,
+                created_at: result.rows[0].created_at
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Speichern des Standorts:', error);
+
+        // Spezifische Fehlermeldungen
+        if (error.code === '23505') { // Duplicate key
+            res.status(409).json({
+                success: false,
+                message: 'Standort existiert bereits'
+            });
+        } else if (error.code === 'ECONNREFUSED') {
+            res.status(503).json({
+                success: false,
+                message: 'Datenbankverbindung fehlgeschlagen'
+            });
+        } else {
+            res.status(500).json({
+                success: false,
+                message: 'Interner Serverfehler beim Speichern des Standorts'
+            });
+        }
+    }
+});
+
+// API Endpunkt zum Abrufen aller Standorte (geschützt mit API-Key)
+router.get('/v1/private/locations', requireApiKey, async (req, res) => {
+    try {
+        const result = await pool.query(
+            `SELECT id, name, latitude, longitude, time_threshold, created_at 
+             FROM locations 
+             ORDER BY created_at DESC`
+        );
+
+        res.json({
+            success: true,
+            data: result.rows
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Abrufen der Standorte:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der Standorte'
+        });
+    }
+});
+
+// API Endpunkt zum Aktualisieren des Zeit-Schwellenwerts für einen Standort
+router.put('/v1/private/locations/:id/threshold', requireApiKey, async (req, res) => {
+    const { id } = req.params;
+    const { time_threshold } = req.body;
+
+    // Validierung
+    if (!time_threshold) {
+        return res.status(400).json({
+            success: false,
+            message: 'time_threshold ist erforderlich'
+        });
+    }
+
+    try {
+        // Prüfen ob Standort existiert
+        const existingLocation = await pool.query(
+            'SELECT id, name FROM locations WHERE id = $1',
+            [id]
+        );
+
+        if (existingLocation.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Standort nicht gefunden'
+            });
+        }
+
+        // Schwellenwert aktualisieren
+        const result = await pool.query(
+            'UPDATE locations SET time_threshold = $1 WHERE id = $2 RETURNING id, name, time_threshold',
+            [time_threshold, id]
+        );
+
+
+
+        res.json({
+            success: true,
+            message: 'Schwellenwert erfolgreich aktualisiert',
+            data: {
+                id: result.rows[0].id,
+                name: result.rows[0].name,
+                time_threshold: result.rows[0].time_threshold
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Aktualisieren des Schwellenwerts:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Interner Serverfehler beim Aktualisieren des Schwellenwerts'
+        });
+    }
+});
+
+// ============================================================================
+// WEB-AUTHENTICATED ROUTES (/api/v1/web/)
+// ============================================================================
+
+// Neue Route zum Generieren eines API-Keys (nur für authentifizierte Web-Benutzer)
+router.post('/v1/web/generate-api-key', async (req, res) => {
+    // Diese Route bleibt für das Web-Interface verfügbar
+    // Hier können Sie einen neuen API-Key generieren
+    try {
+        // Generiere einen zufälligen API-Key
+        const crypto = require('crypto');
+        const apiKey = crypto.randomBytes(32).toString('hex');
+
+        // Speichere den API-Key in der Datenbank
+        const result = await pool.query(
+            `INSERT INTO api_tokens (token, description, standorte, expires_at) 
+             VALUES ($1, $2, $3, $4) 
+             RETURNING id, created_at`,
+            [
+                apiKey,
+                req.body.description || 'Generierter API-Key',
+                req.body.standorte || '',
+                new Date(Date.now() + 2 * 365 * 24 * 60 * 60 * 1000) // 2 Jahre gültig
+            ]
+        );
+
+        res.json({
+            success: true,
+            message: 'API-Key erfolgreich generiert',
+            data: {
+                id: result.rows[0].id,
+                apiKey: apiKey,
+                created_at: result.rows[0].created_at
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Generieren des API-Keys:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Generieren des API-Keys'
+        });
+    }
+});
+
+// Web-authenticated endpoints for location management (for frontend use)
+// These endpoints use session authentication instead of API key authentication
+
+// Web-authenticated endpoint for creating locations
+router.post('/v1/web/create-location', async (req, res) => {
+    // Check if user is authenticated via web session
+    if (!req.session || !req.session.userId) {
+        return res.status(401).json({
+            success: false,
+            message: 'Nicht angemeldet. Bitte melden Sie sich an.'
+        });
+    }
+
+    const { name, lat, lon } = req.body;
+
+    // Validierung
+    if (!name || lat === undefined || lon === undefined) {
+        return res.status(400).json({
+            success: false,
+            message: 'Name, Breitengrad und Längengrad sind erforderlich'
+        });
+    }
+
+    try {
+        // Prüfen ob Standort bereits existiert
+        const existingLocation = await pool.query(
+            'SELECT id FROM locations WHERE name = $1',
+            [name]
+        );
+
+        if (existingLocation.rows.length > 0) {
+            return res.status(409).json({
+                success: false,
+                message: 'Standort existiert bereits in der Datenbank'
+            });
+        }
+
+        // Standort in Datenbank einfügen
+        const result = await pool.query(
+            `INSERT INTO locations (name, latitude, longitude, created_at) 
+             VALUES ($1, $2, $3, $4) 
+             RETURNING id, created_at`,
+            [name, lat, lon, new Date()]
+        );
+
+
+
+        res.json({
+            success: true,
+            message: 'Standort erfolgreich gespeichert',
+            data: {
+                id: result.rows[0].id,
+                name: name,
+                latitude: lat,
+                longitude: lon,
+                created_at: result.rows[0].created_at
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Speichern des Standorts:', error);
+
+        // Spezifische Fehlermeldungen
+        if (error.code === '23505') { // Duplicate key
+            res.status(409).json({
+                success: false,
+                message: 'Standort existiert bereits'
+            });
+        } else if (error.code === 'ECONNREFUSED') {
+            res.status(503).json({
+                success: false,
+                message: 'Datenbankverbindung fehlgeschlagen'
+            });
+        } else {
+            res.status(500).json({
+                success: false,
+                message: 'Interner Serverfehler beim Speichern des Standorts'
+            });
+        }
+    }
+});
+
+// Web-authenticated endpoint for saving tokens
+router.post('/v1/web/save-token', async (req, res) => {
+    // Check if user is authenticated via web session
+    if (!req.session || !req.session.userId) {
+        return res.status(401).json({
+            success: false,
+            message: 'Nicht angemeldet. Bitte melden Sie sich an.'
+        });
+    }
+
+    const { token, description, standorte } = req.body;
+
+    if (!token) {
+        return res.status(400).json({
+            success: false,
+            message: 'Token ist erforderlich'
+        });
+    }
+
+    try {
+        // Prüfen ob Token bereits existiert
+        const existingToken = await pool.query(
+            'SELECT id FROM api_tokens WHERE token = $1',
+            [token]
+        );
+
+        if (existingToken.rows.length > 0) {
+            return res.status(409).json({
+                success: false,
+                message: 'Token existiert bereits in der Datenbank'
+            });
+        }
+
+        // Token in Datenbank einfügen
+        const result = await pool.query(
+            `INSERT INTO api_tokens (token, description, standorte, created_at) 
+             VALUES ($1, $2, $3, $4) 
+             RETURNING id, created_at`,
+            [token, description || 'API-Token', standorte || '', new Date()]
+        );
+
+
+
+        res.json({
+            success: true,
+            message: 'Token erfolgreich gespeichert',
+            data: {
+                id: result.rows[0].id,
+                token: token,
+                description: description || 'API-Token',
+                standorte: standorte || '',
+                created_at: result.rows[0].created_at
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Speichern des Tokens:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Interner Serverfehler beim Speichern des Tokens'
+        });
+    }
+});
+
+// API Endpunkt für GetLocations (geschützt mit API-Key)
+router.get('/v1/private/get-locations', requireApiKey, async (req, res) => {
+    try {
+        const result = await pool.query('SELECT * FROM "GetLocations"');
+
+        res.json({
+            success: true,
+            data: result.rows
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Abrufen der GetLocations:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der GetLocations'
+        });
+    }
+});
+
+// API Entpunkt zum erstellen eines neuen Spielers
+router.post('/v1/private/create-player', requireApiKey, async (req, res) => {
+    const { firstname, lastname, birthdate, rfiduid } = req.body;
+
+    // Validierung
+    if (!firstname || !lastname || !birthdate || !rfiduid) {
+        return res.status(400).json({
+            success: false,
+            message: 'Firstname, Lastname, Birthdate und RFIDUID sind erforderlich'
+        });
+    }
+
+    try {
+        // Prüfen ob Spieler bereits existiert
+        const existingPlayer = await pool.query(
+            'SELECT id FROM players WHERE rfiduid = $1',
+            [rfiduid]
+        );
+
+        if (existingPlayer.rows.length > 0) {
+            return res.status(409).json({
+                success: false,
+                message: 'Spieler existiert bereits in der Datenbank'
+            });
+        }
+
+        // Spieler in Datenbank einfügen
+        const result = await pool.query(
+            `INSERT INTO players (firstname, lastname, birthdate, rfiduid, created_at) 
+             VALUES ($1, $2, $3, $4, $5) 
+             RETURNING id, created_at`,
+            [firstname, lastname, birthdate, rfiduid, new Date()]
+        );
+
+
+
+        res.json({
+            success: true,
+            message: 'Spieler erfolgreich gespeichert',
+            data: {
+                id: result.rows[0].id,
+                firstname: firstname,
+                lastname: lastname,
+                birthdate: birthdate,
+                rfiduid: rfiduid,
+                created_at: result.rows[0].created_at
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Speichern des Spielers:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Interner Serverfehler beim Speichern des Spielers'
+        });
+    }
+});
+
+// API Endpunkt zum erstellen einer neuen Zeit mit RFID UID und Location Name
+router.post('/v1/private/create-time', requireApiKey, async (req, res) => {
+    const { rfiduid, location_name, recorded_time } = req.body;
+
+    // Validierung
+    if (!rfiduid || !location_name || !recorded_time) {
+        return res.status(400).json({
+            success: false,
+            message: 'RFIDUID, Location_name und Recorded_time sind erforderlich'
+        });
+    }
+
+    try {
+        let locationResult;
+        let location_id;
+        let location;
+
+        // Prüfen ob location_name eine ID (numerisch oder UUID) oder ein Name ist
+        const isNumericId = /^\d+$/.test(location_name);
+        const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(location_name);
+        const isId = isNumericId || isUuid;
+
+        if (isId) {
+            // Direkte ID-Suche (numerisch oder UUID)
+            locationResult = await pool.query(
+                'SELECT id, name, time_threshold FROM locations WHERE id = $1',
+                [location_name]
+            );
+        } else {
+            // Name-basierte Suche
+            locationResult = await pool.query(
+                'SELECT id, name, time_threshold FROM locations WHERE name = $1',
+                [location_name]
+            );
+        }
+
+        if (locationResult.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: isId
+                    ? `Standort mit ID '${location_name}' nicht gefunden`
+                    : `Standort '${location_name}' nicht gefunden`
+            });
+        }
+
+        location = locationResult.rows[0];
+        location_id = location.id;
+
+        // Prüfen ob die Zeit über dem Schwellenwert liegt
+        if (location.time_threshold) {
+            // Konvertiere recorded_time zu Sekunden für Vergleich
+            const recordedTimeSeconds = convertTimeToSeconds(recorded_time);
+            const thresholdSeconds = convertIntervalToSeconds(location.time_threshold);
+
+            if (recordedTimeSeconds < thresholdSeconds) {
+                // Convert threshold to readable format
+                const thresholdMinutes = Math.floor(thresholdSeconds / 60);
+                const thresholdSecs = Math.floor(thresholdSeconds % 60);
+                const thresholdMs = Math.floor((thresholdSeconds % 1) * 1000);
+                const thresholdDisplay = thresholdMinutes > 0
+                    ? `${thresholdMinutes}:${thresholdSecs.toString().padStart(2, '0')}.${thresholdMs.toString().padStart(3, '0')}`
+                    : `${thresholdSecs}.${thresholdMs.toString().padStart(3, '0')}`;
+
+                return res.status(400).json({
+                    success: false,
+                    message: `Zeit ${recorded_time} liegt unter dem Schwellenwert von ${thresholdDisplay} für diesen Standort`,
+                    data: {
+                        recorded_time: recorded_time,
+                        threshold: location.time_threshold,
+                        threshold_display: thresholdDisplay,
+                        location_name: location.name,
+                        location_id: location.id
+                    }
+                });
+            }
+        }
+
+
+        // Finde den Spieler mit dieser RFIDUID
+        const playerResult = await pool.query(
+            'SELECT id FROM players WHERE rfiduid = $1',
+            [rfiduid]
+        );
+
+        const player_id = playerResult.rows.length > 0 ? playerResult.rows[0].id : null;
+        console.log(`🔍 RFIDUID: ${rfiduid}, Player ID: ${player_id}`);
+
+        // Zeit mit RFIDUID in die Tabelle einfügen
+        const result = await pool.query(
+            `INSERT INTO times (rfiduid, location_id, recorded_time, player_id, created_at) 
+             VALUES ($1, $2, $3, $4, $5) 
+             RETURNING id, player_id, created_at`,
+            [rfiduid, location_id, recorded_time, player_id, new Date()]
+        );
+
+        // Achievement-Überprüfung nach Zeit-Eingabe (JavaScript)
+        if (result.rows[0].player_id) {
+            try {
+                const AchievementSystem = require('../lib/achievementSystem');
+                const achievementSystem = new AchievementSystem();
+                const newAchievements = await achievementSystem.checkImmediateAchievements(result.rows[0].player_id);
+
+                if (newAchievements.length > 0) {
+                    console.log(`🏆 ${newAchievements.length} neue Achievements für Spieler ${result.rows[0].player_id}:`);
+                    newAchievements.forEach(achievement => {
+                        console.log(`   ${achievement.icon} ${achievement.name} (+${achievement.points} Punkte)`);
+                    });
+                }
+            } catch (achievementError) {
+                console.error('Fehler bei Achievement-Check:', achievementError);
+                // Achievement-Fehler sollen die Zeit-Eingabe nicht blockieren
+            }
+        } else {
+            console.log('⚠️ Kein Spieler verknüpft, keine Achievement-Prüfung');
+        }
+
+        // WebSocket-Event senden für Live-Updates
+        const io = req.app.get('io');
+        if (io) {
+            // Hole die aktuelle Platzierung für diese Zeit
+            const rankResult = await pool.query(
+                `SELECT COUNT(*) + 1 as rank 
+                 FROM times t1 
+                 WHERE t1.location_id = $1 
+                 AND t1.recorded_time < $2`,
+                [location_id, recorded_time]
+            );
+
+            const rank = rankResult.rows[0].rank;
+
+            // Hole Spielerdaten für WebSocket-Event
+            const playerResult = await pool.query(
+                `SELECT firstname, lastname FROM players WHERE id = $1`,
+                [result.rows[0].player_id]
+            );
+
+            const player = playerResult.rows[0];
+            const playerName = player ? `${player.firstname} ${player.lastname}` : 'Unbekannter Spieler';
+
+            // Sende WebSocket-Event an alle verbundenen Clients
+            io.emit('newTime', {
+                id: result.rows[0].id,
+                player_id: result.rows[0].player_id,
+                player_name: playerName,
+                rfiduid: rfiduid,
+                location_name: location.name,
+                recorded_time: recorded_time,
+                rank: rank,
+                created_at: result.rows[0].created_at
+            });
+        }
+
+        res.json({
+            success: true,
+            message: 'Zeit erfolgreich gespeichert',
+            data: {
+                id: result.rows[0].id,
+                player_id: result.rows[0].player_id,
+                rfiduid: rfiduid,
+                location_id: location_id,
+                location_name: location.name,
+                recorded_time: recorded_time,
+                created_at: result.rows[0].created_at,
+                input_type: isId ? (isNumericId ? 'numeric_id' : 'uuid_id') : 'location_name'
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Speichern der Zeit:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Interner Serverfehler beim Speichern der Zeit'
+        });
+    }
+});
+
+// API Endpunkt zum Überprüfen eines Benutzers anhand der RFID UID
+router.post('/v1/private/users/find', requireApiKey, async (req, res) => {
+    const { uid } = req.body;
+
+    // Validierung
+    if (!uid) {
+        return res.status(400).json({
+            success: false,
+            message: 'UID ist erforderlich'
+        });
+    }
+
+    try {
+        // Spieler anhand der RFID UID finden
+        const result = await pool.query(
+            'SELECT rfiduid, firstname, lastname, birthdate FROM players WHERE rfiduid = $1',
+            [uid]
+        );
+
+        if (result.rows.length === 0) {
+            // Benutzer nicht gefunden - gibt leere UserData zurück
+            return res.json({
+                success: true,
+                data: {
+                    uid: "",
+                    firstname: "",
+                    lastname: "",
+                    alter: 0,
+                    exists: false
+                }
+            });
+        }
+
+        const player = result.rows[0];
+
+        // Alter aus dem Geburtsdatum berechnen
+        let age = 0;
+        if (player.birthdate) {
+            const today = new Date();
+            const birthDate = new Date(player.birthdate);
+            age = today.getFullYear() - birthDate.getFullYear();
+
+            // Prüfen ob der Geburtstag dieses Jahr noch nicht war
+            const monthDiff = today.getMonth() - birthDate.getMonth();
+            if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birthDate.getDate())) {
+                age--;
+            }
+        }
+
+
+
+        res.json({
+            success: true,
+            data: {
+                uid: player.rfiduid,
+                firstname: player.firstname,
+                lastname: player.lastname,
+                alter: age,
+                exists: true
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Überprüfen des Benutzers:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Interner Serverfehler beim Überprüfen des Benutzers'
+        });
+    }
+});
+
+
+
+// ============================================================================
+// RFID LINKING & USER MANAGEMENT ENDPOINTS (No API Key required for dashboard)
+// ============================================================================
+
+// Import blacklist module
+const { checkNameAgainstBlacklist, addToBlacklist, removeFromBlacklist, getBlacklist } = require('../config/blacklist-db');
+
+// Create new player with RFID and blacklist validation (no auth required for dashboard)
+router.post('/v1/public/players/create-with-rfid', async (req, res) => {
+    const { rfiduid, firstname, lastname, birthdate, supabase_user_id, agb_accepted } = req.body;
+
+    // Validierung
+    if (!rfiduid || !firstname || !lastname || !birthdate) {
+        return res.status(400).json({
+            success: false,
+            message: 'RFID UID, Vorname, Nachname und Geburtsdatum sind erforderlich'
+        });
+    }
+
+    try {
+        // Blacklist-Prüfung mit Levenshtein-Algorithmus
+        const blacklistCheck = await checkNameAgainstBlacklist(firstname, lastname);
+        if (blacklistCheck.isBlocked) {
+            return res.status(400).json({
+                success: false,
+                message: `Name nicht zulässig: ${blacklistCheck.reason}`,
+                details: blacklistCheck
+            });
+        }
+
+        // Prüfen ob RFID UID bereits existiert
+        const existingRfid = await pool.query(
+            'SELECT id, firstname, lastname FROM players WHERE rfiduid = $1',
+            [rfiduid]
+        );
+
+        if (existingRfid.rows.length > 0) {
+            return res.status(409).json({
+                success: false,
+                message: 'RFID UID existiert bereits',
+                details: {
+                    existingPlayer: {
+                        firstname: existingRfid.rows[0].firstname,
+                        lastname: existingRfid.rows[0].lastname
+                    }
+                }
+            });
+        }
+
+        // Prüfen ob Supabase User bereits verknüpft ist (falls angegeben)
+        if (supabase_user_id) {
+            const existingUser = await pool.query(
+                'SELECT id FROM players WHERE supabase_user_id = $1',
+                [supabase_user_id]
+            );
+
+            if (existingUser.rows.length > 0) {
+                return res.status(409).json({
+                    success: false,
+                    message: 'Dieser Benutzer ist bereits mit einem Spieler verknüpft'
+                });
+            }
+        }
+
+        // Geburtsdatum validieren
+        const birthDate = new Date(birthdate);
+        if (isNaN(birthDate.getTime())) {
+            return res.status(400).json({
+                success: false,
+                message: 'Ungültiges Geburtsdatum'
+            });
+        }
+
+        // Alter berechnen
+        const today = new Date();
+        let age = today.getFullYear() - birthDate.getFullYear();
+        const monthDiff = today.getMonth() - birthDate.getMonth();
+        if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birthDate.getDate())) {
+            age--;
+        }
+
+        // Spieler in Datenbank einfügen
+        const result = await pool.query(
+            `INSERT INTO players (rfiduid, firstname, lastname, birthdate, supabase_user_id, created_at, show_in_leaderboard, agb_accepted) 
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8) 
+             RETURNING id, rfiduid, firstname, lastname, birthdate, created_at, agb_accepted`,
+            [rfiduid, firstname, lastname, birthdate, supabase_user_id || null, new Date(), !!agb_accepted, !!agb_accepted]
+        );
+
+        const newPlayer = result.rows[0];
+
+        res.status(201).json({
+            success: true,
+            message: 'Spieler erfolgreich mit RFID erstellt',
+            data: {
+                id: newPlayer.id,
+                rfiduid: newPlayer.rfiduid,
+                firstname: newPlayer.firstname,
+                lastname: newPlayer.lastname,
+                birthdate: newPlayer.birthdate,
+                age: age,
+                created_at: newPlayer.created_at
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Erstellen des Spielers mit RFID:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Interner Serverfehler beim Erstellen des Spielers'
+        });
+    }
+});
+
+// Create new player with optional Supabase user linking (no auth required for dashboard)
+router.post('/v1/public/players', async (req, res) => {
+    const { firstname, lastname, birthdate, rfiduid, supabase_user_id } = req.body;
+
+    // Validierung
+    if (!firstname || !lastname || !birthdate) {
+        return res.status(400).json({
+            success: false,
+            message: 'Firstname, Lastname und Birthdate sind erforderlich'
+        });
+    }
+
+    try {
+        // Prüfen ob RFID UID bereits existiert (falls angegeben)
+        if (rfiduid) {
+            const existingRfid = await pool.query(
+                'SELECT id FROM players WHERE rfiduid = $1',
+                [rfiduid]
+            );
+
+            if (existingRfid.rows.length > 0) {
+                return res.status(409).json({
+                    success: false,
+                    message: 'RFID UID existiert bereits'
+                });
+            }
+        }
+
+        // Prüfen ob Supabase User bereits verknüpft ist
+        if (supabase_user_id) {
+            const existingUser = await pool.query(
+                'SELECT id FROM players WHERE supabase_user_id = $1',
+                [supabase_user_id]
+            );
+
+            if (existingUser.rows.length > 0) {
+                return res.status(409).json({
+                    success: false,
+                    message: 'Dieser Benutzer ist bereits mit einem Spieler verknüpft'
+                });
+            }
+        }
+
+        // Spieler in Datenbank einfügen
+        const result = await pool.query(
+            `INSERT INTO players (firstname, lastname, birthdate, rfiduid, supabase_user_id, created_at) 
+             VALUES ($1, $2, $3, $4, $5, $6) 
+             RETURNING id, created_at`,
+            [firstname, lastname, birthdate, rfiduid, supabase_user_id, new Date()]
+        );
+
+        res.json({
+            success: true,
+            message: 'Spieler erfolgreich erstellt',
+            data: {
+                id: result.rows[0].id,
+                firstname: firstname,
+                lastname: lastname,
+                birthdate: birthdate,
+                rfiduid: rfiduid,
+                supabase_user_id: supabase_user_id,
+                created_at: result.rows[0].created_at
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Erstellen des Spielers:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Interner Serverfehler beim Erstellen des Spielers'
+        });
+    }
+});
+
+// Link existing player to Supabase user (no auth required for dashboard)
+router.post('/v1/public/link-player', async (req, res) => {
+    const { player_id, supabase_user_id } = req.body;
+
+    // Validierung
+    if (!player_id || !supabase_user_id) {
+        return res.status(400).json({
+            success: false,
+            message: 'Player ID und Supabase User ID sind erforderlich'
+        });
+    }
+
+    try {
+        // Prüfen ob Spieler existiert
+        const playerExists = await pool.query(
+            'SELECT id, firstname, lastname FROM players WHERE id = $1',
+            [player_id]
+        );
+
+        if (playerExists.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Spieler nicht gefunden'
+            });
+        }
+
+        // Prüfen ob Supabase User bereits verknüpft ist
+        const existingLink = await pool.query(
+            'SELECT id FROM players WHERE supabase_user_id = $1',
+            [supabase_user_id]
+        );
+
+        if (existingLink.rows.length > 0) {
+            return res.status(409).json({
+                success: false,
+                message: 'Dieser Benutzer ist bereits mit einem Spieler verknüpft'
+            });
+        }
+
+        // Verknüpfung erstellen
+        const result = await pool.query(
+            'UPDATE players SET supabase_user_id = $1 WHERE id = $2 RETURNING id, firstname, lastname, rfiduid',
+            [supabase_user_id, player_id]
+        );
+
+        const player = result.rows[0];
+
+        // Alle anonymen Zeiten (mit rfiduid aber ohne player_id) mit diesem Spieler verknüpfen
+        if (player.rfiduid) {
+            const updateTimesResult = await pool.query(
+                'UPDATE times SET player_id = $1 WHERE rfiduid = $2 AND player_id IS NULL',
+                [player_id, player.rfiduid]
+            );
+
+            console.log(`✅ ${updateTimesResult.rowCount} anonyme Zeiten mit Spieler ${player_id} verknüpft`);
+        }
+
+        res.json({
+            success: true,
+            message: 'Spieler erfolgreich verknüpft',
+            data: {
+                ...player,
+                linked_times_count: player.rfiduid ? (await pool.query('SELECT COUNT(*) FROM times WHERE rfiduid = $1 AND player_id = $2', [player.rfiduid, player_id])).rows[0].count : 0
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Verknüpfen des Spielers:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Interner Serverfehler beim Verknüpfen des Spielers'
+        });
+    }
+});
+
+// Update player details (name and RFID) for logged-in user
+router.post('/v1/public/update-player-details', async (req, res) => {
+    const { firstname, lastname, rfiduid, birthdate } = req.body;
+    const userId = req.session.userId;
+
+    // Validierung
+    if (!userId || userId === 'anonymous') {
+        return res.status(401).json({
+            success: false,
+            message: 'Bitte logge dich ein'
+        });
+    }
+
+    if (!firstname || !lastname) {
+        return res.status(400).json({
+            success: false,
+            message: 'Vor- und Nachname sind erforderlich'
+        });
+    }
+
+    try {
+        // Finde den Spieler über supabase_user_id
+        const playerResult = await pool.query(
+            'SELECT id FROM players WHERE supabase_user_id = $1',
+            [userId]
+        );
+
+        if (playerResult.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Kein Spieler-Profil gefunden'
+            });
+        }
+
+        const playerId = playerResult.rows[0].id;
+
+        // Prüfe ob RFID bereits verwendet wird (falls angegeben)
+        if (rfiduid) {
+            const rfidCheck = await pool.query(
+                'SELECT id FROM players WHERE rfiduid = $1 AND id != $2',
+                [rfiduid, playerId]
+            );
+
+            if (rfidCheck.rows.length > 0) {
+                return res.status(400).json({
+                    success: false,
+                    message: 'RFID bereits vergeben'
+                });
+            }
+        }
+
+        // Update Spieler-Details
+        const updateResult = await pool.query(
+            'UPDATE players SET firstname = $1, lastname = $2, rfiduid = $3, birthdate = $4, updated_at = NOW() WHERE id = $5 RETURNING *',
+            [firstname, lastname, rfiduid || null, birthdate || null, playerId]
+        );
+
+        res.json({
+            success: true,
+            message: 'Spieler-Details erfolgreich aktualisiert',
+            data: updateResult.rows[0]
+        });
+    } catch (error) {
+        console.error('Error updating player details:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Aktualisieren der Spieler-Details'
+        });
+    }
+});
+
+// Get user times by Supabase user ID (no auth required for dashboard)
+router.get('/v1/public/user-times/:supabase_user_id', async (req, res) => {
+    const { supabase_user_id } = req.params;
+
+    try {
+        // Finde verknüpften Spieler
+        const playerResult = await pool.query(
+            'SELECT id FROM players WHERE supabase_user_id = $1',
+            [supabase_user_id]
+        );
+
+        if (playerResult.rows.length === 0) {
+            return res.json([]); // Noch keine Verknüpfung
+        }
+
+        const player_id = playerResult.rows[0].id;
+
+        // Hole alle Zeiten für diesen Spieler mit Location-Namen
+        const timesResult = await pool.query(`
+            SELECT 
+                t.id,
+                t.recorded_time,
+                t.created_at,
+                l.name as location_name,
+                l.latitude,
+                l.longitude
+            FROM times t
+            JOIN locations l ON t.location_id = l.id
+            WHERE t.player_id = $1
+            ORDER BY t.created_at DESC
+        `, [player_id]);
+
+        res.json({
+            success: true,
+            data: timesResult.rows
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Abrufen der Benutzerzeiten:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der Benutzerzeiten'
+        });
+    }
+});
+
+/**
+ * @swagger
+ * /api/v1/public/user-player/{supabase_user_id}:
+ *   get:
+ *     summary: Spieler-Info anhand der Supabase User ID abrufen
+ *     description: Ruft Spieler-Informationen für das Dashboard ab
+ *     tags: [Public API]
+ *     parameters:
+ *       - in: path
+ *         name: supabase_user_id
+ *         required: true
+ *         schema:
+ *           type: string
+ *           format: uuid
+ *         description: Supabase User ID
+ *     responses:
+ *       200:
+ *         description: Spieler-Informationen
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 data:
+ *                   $ref: '#/components/schemas/Player'
+ *       404:
+ *         description: Spieler nicht gefunden
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/Error'
+ *       500:
+ *         description: Server-Fehler
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/Error'
+ */
+// Get player info by Supabase user ID (no auth required for dashboard)
+router.get('/v1/public/user-player/:supabase_user_id', async (req, res) => {
+    const { supabase_user_id } = req.params;
+
+    try {
+        const result = await pool.query(
+            'SELECT id, firstname, lastname, birthdate, rfiduid, show_in_leaderboard FROM players WHERE supabase_user_id = $1',
+            [supabase_user_id]
+        );
+
+        if (result.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Kein verknüpfter Spieler gefunden'
+            });
+        }
+
+        res.json({
+            success: true,
+            data: result.rows[0]
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Abrufen der Spielerdaten:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der Spielerdaten'
+        });
+    }
+});
+
+// Link user by RFID UID (scanned from QR code)
+router.post('/v1/public/link-by-rfid', async (req, res) => {
+    const { rfiduid, supabase_user_id } = req.body;
+
+    // Validierung
+    if (!rfiduid || !supabase_user_id) {
+        return res.status(400).json({
+            success: false,
+            message: 'RFID UID und Supabase User ID sind erforderlich'
+        });
+    }
+
+    try {
+        // Prüfen ob Spieler mit dieser RFID UID existiert
+        const playerResult = await pool.query(
+            'SELECT id, firstname, lastname, rfiduid, supabase_user_id FROM players WHERE rfiduid = $1',
+            [rfiduid]
+        );
+
+        if (playerResult.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: `Kein Spieler mit RFID UID '${rfiduid}' gefunden. Bitte erstelle zuerst einen Spieler mit dieser RFID UID.`
+            });
+        }
+
+        const player = playerResult.rows[0];
+
+        // Prüfen ob dieser Spieler bereits mit einem anderen Benutzer verknüpft ist
+        if (player.supabase_user_id && player.supabase_user_id !== supabase_user_id) {
+            return res.status(409).json({
+                success: false,
+                message: 'Dieser Spieler ist bereits mit einem anderen Benutzer verknüpft'
+            });
+        }
+
+        // Prüfen ob dieser Benutzer bereits mit einem anderen Spieler verknüpft ist
+        const existingLink = await pool.query(
+            'SELECT id, firstname, lastname FROM players WHERE supabase_user_id = $1 AND id != $2',
+            [supabase_user_id, player.id]
+        );
+
+        if (existingLink.rows.length > 0) {
+            return res.status(409).json({
+                success: false,
+                message: `Du bist bereits mit dem Spieler '${existingLink.rows[0].firstname} ${existingLink.rows[0].lastname}' verknüpft. Ein Benutzer kann nur mit einem Spieler verknüpft sein.`
+            });
+        }
+
+        // Verknüpfung erstellen (falls noch nicht vorhanden)
+        if (!player.supabase_user_id) {
+            await pool.query(
+                'UPDATE players SET supabase_user_id = $1 WHERE id = $2',
+                [supabase_user_id, player.id]
+            );
+        }
+
+        res.json({
+            success: true,
+            message: 'RFID erfolgreich verknüpft',
+            data: {
+                id: player.id,
+                firstname: player.firstname,
+                lastname: player.lastname,
+                rfiduid: player.rfiduid
+            }
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Verknüpfen per RFID UID:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Interner Serverfehler beim Verknüpfen per RFID UID'
+        });
+    }
+});
+
+// ============================================================================
+// ADMIN DASHBOARD ROUTES
+// ============================================================================
+
+// Middleware für Admin-Authentifizierung
+function requireAdminAuth(req, res, next) {
+    if (!req.session.userId) {
+        return res.status(401).json({
+            success: false,
+            message: 'Authentifizierung erforderlich'
+        });
+    }
+    next();
+}
+
+// Middleware für Level 2 Zugriff
+function requireLevel2Access(req, res, next) {
+    if (!req.session.userId || req.session.accessLevel < 2) {
+        return res.status(403).json({
+            success: false,
+            message: 'Insufficient access level'
+        });
+    }
+    next();
+}
+
+// Session-Check für Dashboard
+router.get('/v1/web/check-session', (req, res) => {
+    if (req.session.userId) {
+        res.json({
+            success: true,
+            user: {
+                id: req.session.userId,
+                username: req.session.username,
+                access_level: req.session.accessLevel || 1
+            }
+        });
+    } else {
+        res.status(401).json({
+            success: false,
+            message: 'Not authenticated'
+        });
+    }
+});
+
+// ============================================================================
+// ADMIN DASHBOARD ROUTES (/api/v1/admin/)
+// ============================================================================
+
+// Blacklist-Verwaltung
+router.get('/v1/admin/blacklist', requireAdminAuth, async (req, res) => {
+    try {
+        const blacklist = await getBlacklist();
+        res.json({
+            success: true,
+            data: blacklist
+        });
+    } catch (error) {
+        console.error('Error loading blacklist:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Blacklist'
+        });
+    }
+});
+
+// Blacklist-Eintrag hinzufügen
+router.post('/v1/admin/blacklist', requireAdminAuth, async (req, res) => {
+    const { term, category } = req.body;
+
+    if (!term || !category) {
+        return res.status(400).json({
+            success: false,
+            message: 'Begriff und Kategorie sind erforderlich'
+        });
+    }
+
+    try {
+        // Get admin user info for created_by field
+        const adminUser = req.session.username || 'admin';
+        await addToBlacklist(term, category, adminUser);
+        res.json({
+            success: true,
+            message: 'Begriff erfolgreich zur Blacklist hinzugefügt'
+        });
+    } catch (error) {
+        console.error('Error adding to blacklist:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Hinzufügen zur Blacklist'
+        });
+    }
+});
+
+// Blacklist-Eintrag entfernen
+router.delete('/v1/admin/blacklist', requireAdminAuth, async (req, res) => {
+    const { term, category } = req.body;
+
+    if (!term || !category) {
+        return res.status(400).json({
+            success: false,
+            message: 'Begriff und Kategorie sind erforderlich'
+        });
+    }
+
+    try {
+        await removeFromBlacklist(term, category);
+        res.json({
+            success: true,
+            message: 'Begriff erfolgreich aus der Blacklist entfernt'
+        });
+    } catch (error) {
+        console.error('Error removing from blacklist:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Entfernen aus der Blacklist'
+        });
+    }
+});
+
+// Name gegen Blacklist testen
+router.post('/v1/admin/blacklist/test', requireAdminAuth, async (req, res) => {
+    const { firstname, lastname } = req.body;
+
+    if (!firstname || !lastname) {
+        return res.status(400).json({
+            success: false,
+            message: 'Vorname und Nachname sind erforderlich'
+        });
+    }
+
+    try {
+        // Blacklist-Prüfung mit Levenshtein-Algorithmus
+        const blacklistResult = await checkNameAgainstBlacklist(firstname, lastname);
+
+        res.json({
+            success: true,
+            data: {
+                blacklist: blacklistResult,
+                isBlocked: blacklistResult.isBlocked,
+                reason: blacklistResult.reason,
+                source: blacklistResult.isBlocked ? 'blacklist' : 'none'
+            }
+        });
+    } catch (error) {
+        console.error('Error testing name against blacklist:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Testen des Namens'
+        });
+    }
+});
+
+// Blacklist-Statistiken
+router.get('/v1/admin/blacklist/stats', requireAdminAuth, async (req, res) => {
+    try {
+        const result = await pool.query(`
+            SELECT 
+                category,
+                COUNT(*) as count,
+                MAX(created_at) as last_added
+            FROM blacklist_terms 
+            GROUP BY category 
+            ORDER BY category
+        `);
+
+        const totalResult = await pool.query('SELECT COUNT(*) as total FROM blacklist_terms');
+
+        res.json({
+            success: true,
+            data: {
+                categories: result.rows,
+                total: parseInt(totalResult.rows[0].total)
+            }
+        });
+    } catch (error) {
+        console.error('Error loading blacklist stats:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Blacklist-Statistiken'
+        });
+    }
+});
+
+// LLM-Status prüfen
+router.get('/v1/admin/llm/status', requireAdminAuth, async (req, res) => {
+    try {
+        const status = await testLLMConnection();
+        res.json({
+            success: true,
+            data: status
+        });
+    } catch (error) {
+        console.error('Error checking LLM status:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Prüfen des LLM-Status'
+        });
+    }
+});
+
+// LLM-Test mit Kontext
+router.post('/v1/admin/llm/test', requireAdminAuth, async (req, res) => {
+    const { firstname, lastname, context } = req.body;
+
+    if (!firstname || !lastname) {
+        return res.status(400).json({
+            success: false,
+            message: 'Vorname und Nachname sind erforderlich'
+        });
+    }
+
+    try {
+        const result = await checkNameWithContext(firstname, lastname, context);
+        res.json({
+            success: true,
+            data: result
+        });
+    } catch (error) {
+        console.error('Error testing name with LLM:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Testen mit LLM'
+        });
+    }
+});
+
+// Levenshtein-Test (für Entwicklung/Debugging)
+router.post('/v1/admin/blacklist/levenshtein-test', requireAdminAuth, async (req, res) => {
+    const { firstname, lastname, threshold } = req.body;
+
+    if (!firstname || !lastname) {
+        return res.status(400).json({
+            success: false,
+            message: 'Vorname und Nachname sind erforderlich'
+        });
+    }
+
+    try {
+        const { checkWithLevenshtein, THRESHOLDS } = require('../config/levenshtein');
+        const blacklist = await getBlacklist();
+
+        const testThreshold = threshold || 0.3;
+        const results = {};
+
+        // Teste jede Kategorie
+        for (const [category, terms] of Object.entries(blacklist)) {
+            const levenshteinResult = checkWithLevenshtein(firstname, lastname, terms, testThreshold);
+            results[category] = {
+                hasSimilarTerms: levenshteinResult.hasSimilarTerms,
+                similarTerms: levenshteinResult.similarTerms,
+                threshold: testThreshold,
+                categoryThreshold: THRESHOLDS[category] || 0.3
+            };
+        }
+
+        res.json({
+            success: true,
+            data: {
+                input: { firstname, lastname },
+                threshold: testThreshold,
+                results: results
+            }
+        });
+    } catch (error) {
+        console.error('Error testing Levenshtein:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Testen der Levenshtein-Distanz'
+        });
+    }
+});
+
+// Admin Statistiken
+router.get('/v1/admin/stats', requireAdminAuth, async (req, res) => {
+    try {
+        const playersResult = await pool.query('SELECT COUNT(*) FROM players');
+        const runsResult = await pool.query('SELECT COUNT(*) FROM times');
+        const locationsResult = await pool.query('SELECT COUNT(*) FROM locations');
+        const adminUsersResult = await pool.query('SELECT COUNT(*) FROM adminusers');
+
+        res.json({
+            success: true,
+            data: {
+                players: parseInt(playersResult.rows[0].count),
+                runs: parseInt(runsResult.rows[0].count),
+                locations: parseInt(locationsResult.rows[0].count),
+                adminUsers: parseInt(adminUsersResult.rows[0].count)
+            }
+        });
+    } catch (error) {
+        console.error('Error loading admin stats:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Statistiken'
+        });
+    }
+});
+
+// Admin Spieler-Verwaltung
+router.get('/v1/admin/players', requireAdminAuth, async (req, res) => {
+    try {
+        const result = await pool.query(`
+            SELECT 
+                p.*,
+                COALESCE(CONCAT(p.firstname, ' ', p.lastname), p.firstname, p.lastname) as full_name,
+                CASE WHEN p.supabase_user_id IS NOT NULL THEN true ELSE false END as has_supabase_link
+            FROM players p 
+            ORDER BY p.created_at DESC
+        `);
+
+        res.json({
+            success: true,
+            data: result.rows
+        });
+    } catch (error) {
+        console.error('Error loading players:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Spieler'
+        });
+    }
+});
+
+router.delete('/v1/admin/players/:id', requireAdminAuth, async (req, res) => {
+    const playerId = req.params.id;
+
+    try {
+        // Erst alle zugehörigen Zeiten löschen
+        await pool.query('DELETE FROM times WHERE player_id = $1', [playerId]);
+
+        // Alle zugehörigen Notifications löschen
+        await pool.query('DELETE FROM sent_notifications WHERE player_id = $1', [playerId]);
+
+        // Alle zugehörigen Player Achievements löschen
+        await pool.query('DELETE FROM player_achievements WHERE player_id = $1', [playerId]);
+
+        // Dann den Spieler löschen
+        const result = await pool.query('DELETE FROM players WHERE id = $1', [playerId]);
+
+        if (result.rowCount > 0) {
+            res.json({ success: true, message: 'Spieler erfolgreich gelöscht' });
+        } else {
+            res.status(404).json({ success: false, message: 'Spieler nicht gefunden' });
+        }
+    } catch (error) {
+        console.error('Error deleting player:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Löschen des Spielers'
+        });
+    }
+});
+
+// Admin Läufe-Verwaltung
+router.get('/v1/admin/runs', requireAdminAuth, async (req, res) => {
+    try {
+        const result = await pool.query(`
+            SELECT 
+                t.id,
+                t.player_id,
+                t.location_id,
+                t.recorded_time,
+                EXTRACT(EPOCH FROM t.recorded_time) as time_seconds,
+                t.created_at,
+                COALESCE(CONCAT(p.firstname, ' ', p.lastname), p.firstname, p.lastname) as player_name,
+                l.name as location_name
+            FROM times t
+            LEFT JOIN players p ON t.player_id = p.id
+            LEFT JOIN locations l ON t.location_id = l.id
+            ORDER BY t.created_at DESC
+            LIMIT 1000
+        `);
+
+        res.json({
+            success: true,
+            data: result.rows
+        });
+    } catch (error) {
+        console.error('Error loading runs:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Läufe'
+        });
+    }
+});
+
+// GET einzelner Lauf
+router.get('/v1/admin/runs/:id', requireAdminAuth, async (req, res) => {
+    try {
+        const { id } = req.params;
+
+        const result = await pool.query(`
+            SELECT 
+                t.id,
+                t.player_id,
+                t.location_id,
+                t.recorded_time,
+                EXTRACT(EPOCH FROM t.recorded_time) as time_seconds,
+                t.created_at,
+                COALESCE(CONCAT(p.firstname, ' ', p.lastname), p.firstname, p.lastname) as player_name,
+                l.name as location_name
+            FROM times t
+            LEFT JOIN players p ON t.player_id = p.id
+            LEFT JOIN locations l ON t.location_id = l.id
+            WHERE t.id = $1
+        `, [id]);
+
+        if (result.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Lauf nicht gefunden'
+            });
+        }
+
+        res.json({
+            success: true,
+            data: result.rows[0]
+        });
+    } catch (error) {
+        console.error('Error loading run:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden des Laufs'
+        });
+    }
+});
+
+router.delete('/v1/admin/runs/:id', requireAdminAuth, async (req, res) => {
+    const runId = req.params.id;
+
+    try {
+        const result = await pool.query('DELETE FROM times WHERE id = $1', [runId]);
+
+        if (result.rowCount > 0) {
+            res.json({ success: true, message: 'Lauf erfolgreich gelöscht' });
+        } else {
+            res.status(404).json({ success: false, message: 'Lauf nicht gefunden' });
+        }
+    } catch (error) {
+        console.error('Error deleting run:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Löschen des Laufs'
+        });
+    }
+});
+
+// Admin Standort-Verwaltung
+router.get('/v1/admin/locations', requireAdminAuth, async (req, res) => {
+    try {
+        const result = await pool.query('SELECT * FROM locations ORDER BY name');
+
+        res.json({
+            success: true,
+            data: result.rows
+        });
+    } catch (error) {
+        console.error('Error loading locations:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Standorte'
+        });
+    }
+});
+
+router.delete('/v1/admin/locations/:id', requireAdminAuth, async (req, res) => {
+    const locationId = req.params.id;
+
+    try {
+        // Prüfen ob noch Läufe an diesem Standort existieren
+        const timesResult = await pool.query('SELECT COUNT(*) FROM times WHERE location_id = $1', [locationId]);
+        const timesCount = parseInt(timesResult.rows[0].count);
+
+        if (timesCount > 0) {
+            return res.status(400).json({
+                success: false,
+                message: `Standort kann nicht gelöscht werden. Es existieren noch ${timesCount} Läufe an diesem Standort.`
+            });
+        }
+
+        const result = await pool.query('DELETE FROM locations WHERE id = $1', [locationId]);
+
+        if (result.rowCount > 0) {
+            res.json({ success: true, message: 'Standort erfolgreich gelöscht' });
+        } else {
+            res.status(404).json({ success: false, message: 'Standort nicht gefunden' });
+        }
+    } catch (error) {
+        console.error('Error deleting location:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Löschen des Standorts'
+        });
+    }
+});
+
+// Admin-Benutzer-Verwaltung
+router.get('/v1/admin/adminusers', requireAdminAuth, async (req, res) => {
+    try {
+        const result = await pool.query(`
+            SELECT id, username, access_level, is_active, created_at, last_login 
+            FROM adminusers 
+            ORDER BY created_at DESC
+        `);
+
+        res.json({
+            success: true,
+            data: result.rows
+        });
+    } catch (error) {
+        console.error('Error loading admin users:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Admin-Benutzer'
+        });
+    }
+});
+
+router.delete('/v1/admin/adminusers/:id', requireAdminAuth, async (req, res) => {
+    const userId = req.params.id;
+
+    // Verhindern, dass sich selbst löscht
+    if (parseInt(userId) === req.session.userId) {
+        return res.status(400).json({
+            success: false,
+            message: 'Sie können sich nicht selbst löschen'
+        });
+    }
+
+    try {
+        const result = await pool.query('DELETE FROM adminusers WHERE id = $1', [userId]);
+
+        if (result.rowCount > 0) {
+            res.json({ success: true, message: 'Admin-Benutzer erfolgreich gelöscht' });
+        } else {
+            res.status(404).json({ success: false, message: 'Admin-Benutzer nicht gefunden' });
+        }
+    } catch (error) {
+        console.error('Error deleting admin user:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Löschen des Admin-Benutzers'
+        });
+    }
+});
+
+// ============================================================================
+// PAGE VIEWS TRACKING
+// ============================================================================
+
+// Track page view
+router.post('/v1/public/track-page-view', async (req, res) => {
+    try {
+        const { page, userAgent, ipAddress, referer } = req.body;
+
+        await pool.query(`
+            INSERT INTO page_views (page, user_agent, ip_address, referer)
+            VALUES ($1, $2, $3, $4)
+        `, [page, userAgent, ipAddress, referer]);
+
+        res.json({ success: true });
+    } catch (error) {
+        console.error('Error tracking page view:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Tracking der Seitenaufrufe'
+        });
+    }
+});
+
+// ============================================================================
+// LEADERBOARD ROUTES (moved from public.js)
+// ============================================================================
+
+// Public endpoint für Standorte (keine Authentifizierung erforderlich)
+router.get('/v1/public/locations', async (req, res) => {
+    try {
+        const result = await pool.query('SELECT * FROM "GetLocations"');
+
+        res.json({
+            success: true,
+            data: result.rows
+        });
+
+    } catch (error) {
+        console.error('Fehler beim Abrufen der getlocations:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der Standorte'
+        });
+    }
+});
+
+/**
+ * @swagger
+ * /api/v1/public/times:
+ *   get:
+ *     summary: Alle Zeiten mit Standort-Informationen abrufen
+ *     description: Ruft alle aufgezeichneten Zeiten mit Standort-Details ab
+ *     tags: [Public API]
+ *     parameters:
+ *       - in: query
+ *         name: location
+ *         schema:
+ *           type: string
+ *         description: Filter nach Standort-ID
+ *       - in: query
+ *         name: limit
+ *         schema:
+ *           type: integer
+ *           default: 100
+ *         description: Maximale Anzahl der Ergebnisse
+ *     responses:
+ *       200:
+ *         description: Liste aller Zeiten
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 data:
+ *                   type: array
+ *                   items:
+ *                     type: object
+ *                     properties:
+ *                       id:
+ *                         type: string
+ *                         format: uuid
+ *                       player_id:
+ *                         type: string
+ *                         format: uuid
+ *                       location_id:
+ *                         type: string
+ *                         format: uuid
+ *                       recorded_time:
+ *                         type: object
+ *                         properties:
+ *                           seconds:
+ *                             type: number
+ *                           minutes:
+ *                             type: number
+ *                           milliseconds:
+ *                             type: number
+ *                       created_at:
+ *                         type: string
+ *                         format: date-time
+ *                       location_name:
+ *                         type: string
+ *                       latitude:
+ *                         type: number
+ *                       longitude:
+ *                         type: number
+ *       500:
+ *         description: Server-Fehler
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/Error'
+ */
+// Public route to get times for location with parameter
+router.get('/v1/public/times', async (req, res) => {
+    const { location } = req.query;
+
+    try {
+        // First, let's check if the view exists and has data
+        const viewCheck = await pool.query('SELECT COUNT(*) as count FROM "GetTimesWithPlayerAndLocation"');
+
+        // Check what location names are available
+        const availableLocations = await pool.query('SELECT DISTINCT location_name FROM "GetTimesWithPlayerAndLocation"');
+
+        // Now search for the specific location
+        const result = await pool.query('SELECT * FROM "GetTimesWithPlayerAndLocation" WHERE location_name = $1', [location]);
+
+        res.json({
+            success: true,
+            data: result.rows,
+            debug: {
+                searchedFor: location,
+                totalRecords: viewCheck.rows[0].count,
+                availableLocations: availableLocations.rows.map(r => r.location_name),
+                foundRecords: result.rows.length
+            }
+        });
+
+    } catch (error) {
+        console.error('❌ Fehler beim Abrufen der Zeiten:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der Zeiten',
+            error: error.message
+        });
+    }
+});
+
+// Public route to get all times with player and location details for leaderboard
+router.get('/v1/public/times-with-details', async (req, res) => {
+    try {
+        const { location, period } = req.query;
+
+        // Build WHERE clause for location filter
+        let locationFilter = '';
+        if (location && location !== 'all') {
+            locationFilter = `AND l.name ILIKE '%${location}%'`;
+        }
+
+        // Build WHERE clause for date filter using PostgreSQL timezone functions
+        let dateFilter = '';
+        if (period === 'today') {
+            // Today in local timezone (UTC+2)
+            dateFilter = `AND DATE(t.created_at AT TIME ZONE 'UTC' AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE`;
+        } else if (period === 'week') {
+            // This week starting from Monday in local timezone
+            dateFilter = `AND DATE(t.created_at AT TIME ZONE 'UTC' AT TIME ZONE 'Europe/Berlin') >= DATE_TRUNC('week', CURRENT_DATE)`;
+        } else if (period === 'month') {
+            // This month starting from 1st in local timezone
+            dateFilter = `AND DATE(t.created_at AT TIME ZONE 'UTC' AT TIME ZONE 'Europe/Berlin') >= DATE_TRUNC('month', CURRENT_DATE)`;
+        }
+
+        // Get all times with player and location details, ordered by time (fastest first)
+        // Only show times from players who have opted into leaderboard visibility
+        // SECURITY: Only return data needed for leaderboard display
+        const result = await pool.query(`
+            SELECT 
+                EXTRACT(EPOCH FROM t.recorded_time) as recorded_time_seconds,
+                t.created_at,
+                json_build_object(
+                    'firstname', p.firstname,
+                    'lastname', p.lastname
+                ) as player,
+                json_build_object(
+                    'name', l.name
+                ) as location
+            FROM times t
+            LEFT JOIN players p ON t.player_id = p.id
+            LEFT JOIN locations l ON t.location_id = l.id
+            WHERE 1=1 ${locationFilter} ${dateFilter}
+            AND p.show_in_leaderboard = true
+            ORDER BY t.recorded_time ASC
+            LIMIT 50
+        `);
+
+        // Convert seconds to minutes:seconds.milliseconds format
+        const formattedResults = result.rows.map(row => {
+            const totalSeconds = parseFloat(row.recorded_time_seconds);
+            const minutes = Math.floor(totalSeconds / 60);
+            const seconds = Math.floor(totalSeconds % 60);
+            const milliseconds = Math.floor((totalSeconds % 1) * 1000);
+
+            return {
+                ...row,
+                recorded_time: {
+                    minutes: minutes,
+                    seconds: seconds,
+                    milliseconds: milliseconds
+                }
+            };
+        });
+
+        res.json(formattedResults);
+
+    } catch (error) {
+        console.error('❌ Fehler beim Abrufen der Zeiten mit Details:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der Zeiten mit Details',
+            error: error.message
+        });
+    }
+});
+
+// Get page statistics
+router.get('/v1/admin/page-stats', requireAdminAuth, async (req, res) => {
+    try {
+        // Page views for today, this week, this month
+        const today = new Date();
+        const startOfDay = new Date(today.getFullYear(), today.getMonth(), today.getDate());
+        const startOfWeek = new Date(today);
+        startOfWeek.setDate(today.getDate() - today.getDay());
+        startOfWeek.setHours(0, 0, 0, 0);
+        const startOfMonth = new Date(today.getFullYear(), today.getMonth(), 1);
+
+        // Today's page views
+        const todayViews = await pool.query(`
+            SELECT page, COUNT(*) as count
+            FROM page_views 
+            WHERE created_at >= $1
+            GROUP BY page
+            ORDER BY count DESC
+        `, [startOfDay]);
+
+        // This week's page views
+        const weekViews = await pool.query(`
+            SELECT page, COUNT(*) as count
+            FROM page_views 
+            WHERE created_at >= $1
+            GROUP BY page
+            ORDER BY count DESC
+        `, [startOfWeek]);
+
+        // This month's page views
+        const monthViews = await pool.query(`
+            SELECT page, COUNT(*) as count
+            FROM page_views 
+            WHERE created_at >= $1
+            GROUP BY page
+            ORDER BY count DESC
+        `, [startOfMonth]);
+
+        // Total page views
+        const totalViews = await pool.query(`
+            SELECT page, COUNT(*) as count
+            FROM page_views 
+            GROUP BY page
+            ORDER BY count DESC
+        `);
+
+        // Player/Supabase link statistics
+        const linkStats = await pool.query(`
+            SELECT 
+                COUNT(*) as total_players,
+                COUNT(CASE WHEN supabase_user_id IS NOT NULL THEN 1 END) as linked_players,
+                CAST(
+                    ROUND(
+                        (COUNT(CASE WHEN supabase_user_id IS NOT NULL THEN 1 END)::numeric / COUNT(*)) * 100, 2
+                    ) AS DECIMAL(5,2)
+                ) as link_percentage
+            FROM players
+        `);
+
+        res.json({
+            success: true,
+            data: {
+                today: todayViews.rows,
+                week: weekViews.rows,
+                month: monthViews.rows,
+                total: totalViews.rows,
+                linkStats: linkStats.rows[0]
+            }
+        });
+    } catch (error) {
+        console.error('Error loading page statistics:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Seitenstatistiken'
+        });
+    }
+});
+
+// ============================================================================
+// POST/PUT ROUTES FÜR CRUD-OPERATIONEN
+// ============================================================================
+
+// Admin Spieler - POST (Hinzufügen)
+router.post('/v1/admin/players', requireAdminAuth, async (req, res) => {
+    try {
+        const { full_name, rfiduid, supabase_user_id } = req.body;
+
+        // Name in firstname und lastname aufteilen
+        const nameParts = full_name ? full_name.trim().split(' ') : [];
+        const firstname = nameParts[0] || '';
+        const lastname = nameParts.slice(1).join(' ') || '';
+
+        const result = await pool.query(
+            `INSERT INTO players (firstname, lastname, rfiduid, supabase_user_id, created_at) 
+             VALUES ($1, $2, $3, $4, NOW()) 
+             RETURNING *`,
+            [firstname, lastname, rfiduid || null, supabase_user_id || null]
+        );
+
+        res.json({
+            success: true,
+            message: 'Spieler erfolgreich hinzugefügt',
+            data: result.rows[0]
+        });
+    } catch (error) {
+        console.error('Error creating player:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Hinzufügen des Spielers'
+        });
+    }
+});
+
+// Admin Spieler - PUT (Bearbeiten)
+router.put('/v1/admin/players/:id', requireAdminAuth, async (req, res) => {
+    try {
+        const playerId = req.params.id;
+        const { full_name, rfiduid, supabase_user_id } = req.body;
+
+        // Name in firstname und lastname aufteilen
+        const nameParts = full_name ? full_name.trim().split(' ') : [];
+        const firstname = nameParts[0] || '';
+        const lastname = nameParts.slice(1).join(' ') || '';
+
+        const result = await pool.query(
+            `UPDATE players 
+             SET firstname = $1, lastname = $2, rfiduid = $3, supabase_user_id = $4 
+             WHERE id = $5 
+             RETURNING *`,
+            [firstname, lastname, rfiduid || null, supabase_user_id || null, playerId]
+        );
+
+        if (result.rowCount > 0) {
+            res.json({
+                success: true,
+                message: 'Spieler erfolgreich aktualisiert',
+                data: result.rows[0]
+            });
+        } else {
+            res.status(404).json({ success: false, message: 'Spieler nicht gefunden' });
+        }
+    } catch (error) {
+        console.error('Error updating player:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Aktualisieren des Spielers'
+        });
+    }
+});
+
+// Admin Standorte - POST (Hinzufügen)
+router.post('/v1/admin/locations', requireAdminAuth, async (req, res) => {
+    try {
+        const { name, latitude, longitude, time_threshold } = req.body;
+
+        const result = await pool.query(
+            `INSERT INTO locations (name, latitude, longitude, time_threshold, created_at) 
+             VALUES ($1, $2, $3, $4, NOW()) 
+             RETURNING *`,
+            [name, latitude, longitude, time_threshold || null]
+        );
+
+        res.json({
+            success: true,
+            message: 'Standort erfolgreich hinzugefügt',
+            data: result.rows[0]
+        });
+    } catch (error) {
+        console.error('Error creating location:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Hinzufügen des Standorts'
+        });
+    }
+});
+
+// Admin Standorte - PUT (Bearbeiten)
+router.put('/v1/admin/locations/:id', requireAdminAuth, async (req, res) => {
+    try {
+        const locationId = req.params.id;
+        const { name, latitude, longitude, time_threshold } = req.body;
+
+        const result = await pool.query(
+            `UPDATE locations 
+             SET name = $1, latitude = $2, longitude = $3, time_threshold = $4 
+             WHERE id = $5 
+             RETURNING *`,
+            [name, latitude, longitude, time_threshold || null, locationId]
+        );
+
+        if (result.rowCount > 0) {
+            res.json({
+                success: true,
+                message: 'Standort erfolgreich aktualisiert',
+                data: result.rows[0]
+            });
+        } else {
+            res.status(404).json({ success: false, message: 'Standort nicht gefunden' });
+        }
+    } catch (error) {
+        console.error('Error updating location:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Aktualisieren des Standorts'
+        });
+    }
+});
+
+// Admin Läufe - POST (Hinzufügen)
+router.post('/v1/admin/runs', requireAdminAuth, async (req, res) => {
+    try {
+        const { player_id, location_id, time_seconds } = req.body;
+
+        // Prüfen ob Location existiert und Threshold abrufen
+        const locationResult = await pool.query(
+            'SELECT id, name, time_threshold FROM locations WHERE id = $1',
+            [location_id]
+        );
+
+        if (locationResult.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Standort nicht gefunden'
+            });
+        }
+
+        const location = locationResult.rows[0];
+
+        // Prüfen ob die Zeit über dem Schwellenwert liegt
+        if (location.time_threshold) {
+            const thresholdSeconds = convertIntervalToSeconds(location.time_threshold);
+
+            if (time_seconds < thresholdSeconds) {
+                return res.status(400).json({
+                    success: false,
+                    message: `Zeit ${time_seconds}s liegt unter dem Schwellenwert von ${location.time_threshold} für diesen Standort`,
+                    data: {
+                        recorded_time: `${time_seconds}s`,
+                        threshold: location.time_threshold,
+                        location_name: location.name
+                    }
+                });
+            }
+        }
+
+        // Zeit in INTERVAL konvertieren
+        const timeInterval = `${time_seconds} seconds`;
+
+        const result = await pool.query(
+            `INSERT INTO times (player_id, location_id, recorded_time, created_at) 
+             VALUES ($1, $2, $3, NOW()) 
+             RETURNING *`,
+            [player_id, location_id, timeInterval]
+        );
+
+        // Achievement-Überprüfung nach Zeit-Eingabe (JavaScript)
+        try {
+            const AchievementSystem = require('../lib/achievementSystem');
+            const achievementSystem = new AchievementSystem();
+            const newAchievements = await achievementSystem.checkImmediateAchievements(player_id);
+
+            if (newAchievements.length > 0) {
+                console.log(`🏆 ${newAchievements.length} neue Achievements für Spieler ${player_id}:`);
+                newAchievements.forEach(achievement => {
+                    console.log(`   ${achievement.icon} ${achievement.name} (+${achievement.points} Punkte)`);
+                });
+            }
+        } catch (achievementError) {
+            console.error('Fehler bei Achievement-Check:', achievementError);
+            // Achievement-Fehler sollen die Zeit-Eingabe nicht blockieren
+        }
+
+        res.json({
+            success: true,
+            message: 'Lauf erfolgreich hinzugefügt',
+            data: result.rows[0]
+        });
+    } catch (error) {
+        console.error('Error creating run:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Hinzufügen des Laufs'
+        });
+    }
+});
+
+// Admin Läufe - PUT (Bearbeiten)
+router.put('/v1/admin/runs/:id', requireAdminAuth, async (req, res) => {
+    try {
+        const runId = req.params.id;
+        const { player_id, location_id, time_seconds } = req.body;
+
+        // Zeit in INTERVAL konvertieren
+        const timeInterval = `${time_seconds} seconds`;
+
+        const result = await pool.query(
+            `UPDATE times 
+             SET player_id = $1, location_id = $2, recorded_time = $3 
+             WHERE id = $4 
+             RETURNING *`,
+            [player_id, location_id, timeInterval, runId]
+        );
+
+        if (result.rowCount > 0) {
+            res.json({
+                success: true,
+                message: 'Lauf erfolgreich aktualisiert',
+                data: result.rows[0]
+            });
+        } else {
+            res.status(404).json({ success: false, message: 'Lauf nicht gefunden' });
+        }
+    } catch (error) {
+        console.error('Error updating run:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Aktualisieren des Laufs'
+        });
+    }
+});
+
+// Admin-Benutzer - POST (Hinzufügen)
+router.post('/v1/admin/adminusers', requireAdminAuth, async (req, res) => {
+    try {
+        const { username, password, access_level } = req.body;
+
+        // Passwort hashen
+        const saltRounds = 10;
+        const hashedPassword = await bcrypt.hash(password, saltRounds);
+
+        const result = await pool.query(
+            `INSERT INTO adminusers (username, password_hash, access_level, is_active, created_at) 
+             VALUES ($1, $2, $3, true, NOW()) 
+             RETURNING id, username, access_level, is_active, created_at`,
+            [username, hashedPassword, access_level]
+        );
+
+        res.json({
+            success: true,
+            message: 'Admin-Benutzer erfolgreich hinzugefügt',
+            data: result.rows[0]
+        });
+    } catch (error) {
+        console.error('Error creating admin user:', error);
+        if (error.code === '23505') { // Unique constraint violation
+            res.status(400).json({
+                success: false,
+                message: 'Benutzername bereits vergeben'
+            });
+        } else {
+            res.status(500).json({
+                success: false,
+                message: 'Fehler beim Hinzufügen des Admin-Benutzers'
+            });
+        }
+    }
+});
+
+// Admin-Benutzer - PUT (Bearbeiten)
+router.put('/v1/admin/adminusers/:id', requireAdminAuth, async (req, res) => {
+    try {
+        const userId = req.params.id;
+        const { username, password, access_level } = req.body;
+
+        // Verhindern, dass sich selbst bearbeitet
+        if (parseInt(userId) === req.session.userId) {
+            return res.status(400).json({
+                success: false,
+                message: 'Sie können sich nicht selbst bearbeiten'
+            });
+        }
+
+        let query, params;
+
+        if (password) {
+            // Passwort hashen
+            const saltRounds = 10;
+            const hashedPassword = await bcrypt.hash(password, saltRounds);
+
+            query = `UPDATE adminusers 
+                     SET username = $1, password_hash = $2, access_level = $3 
+                     WHERE id = $4 
+                     RETURNING id, username, access_level, is_active, created_at`;
+            params = [username, hashedPassword, access_level, userId];
+        } else {
+            query = `UPDATE adminusers 
+                     SET username = $1, access_level = $2 
+                     WHERE id = $3 
+                     RETURNING id, username, access_level, is_active, created_at`;
+            params = [username, access_level, userId];
+        }
+
+        const result = await pool.query(query, params);
+
+        if (result.rowCount > 0) {
+            res.json({
+                success: true,
+                message: 'Admin-Benutzer erfolgreich aktualisiert',
+                data: result.rows[0]
+            });
+        } else {
+            res.status(404).json({ success: false, message: 'Admin-Benutzer nicht gefunden' });
+        }
+    } catch (error) {
+        console.error('Error updating admin user:', error);
+        if (error.code === '23505') { // Unique constraint violation
+            res.status(400).json({
+                success: false,
+                message: 'Benutzername bereits vergeben'
+            });
+        } else {
+            res.status(500).json({
+                success: false,
+                message: 'Fehler beim Aktualisieren des Admin-Benutzers'
+            });
+        }
+    }
+});
+
+// ==================== BEST TIMES ENDPOINTS ====================
+
+/**
+ * @swagger
+ * /api/v1/public/best-times:
+ *   get:
+ *     summary: Beste Zeiten abrufen
+ *     description: Ruft die besten Zeiten des Tages, der Woche und des Monats ab
+ *     tags: [Times]
+ *     responses:
+ *       200:
+ *         description: Beste Zeiten erfolgreich abgerufen
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 data:
+ *                   type: object
+ *                   properties:
+ *                     daily:
+ *                       type: object
+ *                       properties:
+ *                         player_id:
+ *                           type: string
+ *                           format: uuid
+ *                         player_name:
+ *                           type: string
+ *                         best_time:
+ *                           type: string
+ *                           format: time
+ *                     weekly:
+ *                       type: object
+ *                       properties:
+ *                         player_id:
+ *                           type: string
+ *                           format: uuid
+ *                         player_name:
+ *                           type: string
+ *                         best_time:
+ *                           type: string
+ *                           format: time
+ *                     monthly:
+ *                       type: object
+ *                       properties:
+ *                         player_id:
+ *                           type: string
+ *                           format: uuid
+ *                         player_name:
+ *                           type: string
+ *                         best_time:
+ *                           type: string
+ *                           format: time
+ *       500:
+ *         description: Server-Fehler
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/Error'
+ */
+// Get best times (daily, weekly, monthly)
+router.get('/v1/public/best-times', async (req, res) => {
+    try {
+        const currentDate = new Date();
+        const today = currentDate.toISOString().split('T')[0];
+        const weekStart = new Date(currentDate.setDate(currentDate.getDate() - currentDate.getDay()));
+        const monthStart = new Date(currentDate.getFullYear(), currentDate.getMonth(), 1);
+
+        // Get daily best
+        const dailyResult = await pool.query(`
+            WITH daily_best AS (
+                SELECT 
+                    t.player_id,
+                    MIN(t.recorded_time) as best_time,
+                    CONCAT(p.firstname, ' ', p.lastname) as player_name
+                FROM times t
+                JOIN players p ON t.player_id = p.id
+                WHERE DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = $1
+                AND p.show_in_leaderboard = true
+                GROUP BY t.player_id, p.firstname, p.lastname
+            )
+            SELECT 
+                player_id,
+                player_name,
+                best_time
+            FROM daily_best
+            WHERE best_time = (SELECT MIN(best_time) FROM daily_best)
+            LIMIT 1
+        `, [today]);
+
+        // Get weekly best
+        const weeklyResult = await pool.query(`
+            WITH weekly_best AS (
+                SELECT 
+                    t.player_id,
+                    MIN(t.recorded_time) as best_time,
+                    CONCAT(p.firstname, ' ', p.lastname) as player_name
+                FROM times t
+                JOIN players p ON t.player_id = p.id
+                WHERE DATE(t.created_at AT TIME ZONE 'Europe/Berlin') >= $1
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') <= $2
+                AND p.show_in_leaderboard = true
+                GROUP BY t.player_id, p.firstname, p.lastname
+            )
+            SELECT 
+                player_id,
+                player_name,
+                best_time
+            FROM weekly_best
+            WHERE best_time = (SELECT MIN(best_time) FROM weekly_best)
+            LIMIT 1
+        `, [weekStart.toISOString().split('T')[0], today]);
+
+        // Get monthly best
+        const monthlyResult = await pool.query(`
+            WITH monthly_best AS (
+                SELECT 
+                    t.player_id,
+                    MIN(t.recorded_time) as best_time,
+                    CONCAT(p.firstname, ' ', p.lastname) as player_name
+                FROM times t
+                JOIN players p ON t.player_id = p.id
+                WHERE DATE(t.created_at AT TIME ZONE 'Europe/Berlin') >= $1
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') <= $2
+                AND p.show_in_leaderboard = true
+                GROUP BY t.player_id, p.firstname, p.lastname
+            )
+            SELECT 
+                player_id,
+                player_name,
+                best_time
+            FROM monthly_best
+            WHERE best_time = (SELECT MIN(best_time) FROM monthly_best)
+            LIMIT 1
+        `, [monthStart.toISOString().split('T')[0], today]);
+
+        res.json({
+            success: true,
+            data: {
+                daily: dailyResult.rows[0] || null,
+                weekly: weeklyResult.rows[0] || null,
+                monthly: monthlyResult.rows[0] || null
+            }
+        });
+    } catch (error) {
+        console.error('Error fetching best times:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der Bestzeiten',
+            error: error.message
+        });
+    }
+});
+
+// ==================== LOGGING ENDPOINT ====================
+
+// Log endpoint for client-side logging
+router.post('/v1/public/log', async (req, res) => {
+    try {
+        const { level, message, playerId } = req.body;
+        const timestamp = new Date().toISOString();
+
+        console.log(`[${timestamp}] [${level?.toUpperCase() || 'INFO'}] [Player: ${playerId || 'unknown'}] ${message}`);
+
+        res.json({ success: true });
+    } catch (error) {
+        console.error('Error processing log:', error);
+        res.status(500).json({ success: false });
+    }
+});
+
+// ==================== PUSH NOTIFICATION ENDPOINTS ====================
+
+// Import enhanced player notifications
+const enhancedNotifications = require('../scripts/enhanced_player_notifications');
+
+// Send push notification to specific player
+router.post('/v1/player/push', async (req, res) => {
+    try {
+        const { playerId, title, message, data } = req.body;
+
+        if (!playerId || !title || !message) {
+            return res.status(400).json({
+                success: false,
+                message: 'Player ID, title und message sind erforderlich'
+            });
+        }
+
+        const result = await enhancedNotifications.sendPushToPlayer(playerId, title, message, data);
+
+        if (result.success) {
+            res.json({
+                success: true,
+                message: 'Push notification gesendet'
+            });
+        } else {
+            res.status(400).json({
+                success: false,
+                message: result.reason || 'Push notification konnte nicht gesendet werden'
+            });
+        }
+    } catch (error) {
+        console.error('Error sending push notification:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Senden der Push Notification'
+        });
+    }
+});
+
+// Send achievement notification to player
+router.post('/v1/player/achievement-push', async (req, res) => {
+    try {
+        const { playerId, achievement } = req.body;
+
+        if (!playerId || !achievement) {
+            return res.status(400).json({
+                success: false,
+                message: 'Player ID und Achievement sind erforderlich'
+            });
+        }
+
+        const result = await enhancedNotifications.sendAchievementNotification(playerId, achievement);
+
+        if (result.success) {
+            res.json({
+                success: true,
+                message: 'Achievement notification gesendet'
+            });
+        } else {
+            res.status(400).json({
+                success: false,
+                message: result.reason || 'Achievement notification konnte nicht gesendet werden'
+            });
+        }
+    } catch (error) {
+        console.error('Error sending achievement notification:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Senden der Achievement Notification'
+        });
+    }
+});
+
+// Send best time notification to player
+router.post('/v1/player/best-time-push', async (req, res) => {
+    try {
+        const { playerId, timeType, locationName, time } = req.body;
+
+        if (!playerId || !timeType || !locationName || !time) {
+            return res.status(400).json({
+                success: false,
+                message: 'Player ID, timeType, locationName und time sind erforderlich'
+            });
+        }
+
+        const result = await enhancedNotifications.sendBestTimeNotification(playerId, timeType, locationName, time);
+
+        if (result.success) {
+            res.json({
+                success: true,
+                message: 'Best time notification gesendet'
+            });
+        } else {
+            res.status(400).json({
+                success: false,
+                message: result.reason || 'Best time notification konnte nicht gesendet werden'
+            });
+        }
+    } catch (error) {
+        console.error('Error sending best time notification:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Senden der Best Time Notification'
+        });
+    }
+});
+
+// Send notification to all players
+router.post('/v1/player/broadcast-push', async (req, res) => {
+    try {
+        const { title, message, data } = req.body;
+
+        if (!title || !message) {
+            return res.status(400).json({
+                success: false,
+                message: 'Title und message sind erforderlich'
+            });
+        }
+
+        const result = await enhancedNotifications.sendNotificationToAllPlayers(title, message, data);
+
+        res.json({
+            success: true,
+            message: `Notification an ${result.sent}/${result.total} Spieler gesendet`,
+            sent: result.sent,
+            total: result.total
+        });
+    } catch (error) {
+        console.error('Error sending broadcast notification:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Senden der Broadcast Notification'
+        });
+    }
+});
+
+// Get player push status
+router.get('/v1/player/push-status/:playerId', async (req, res) => {
+    try {
+        const { playerId } = req.params;
+
+        const isEnabled = await enhancedNotifications.isPlayerPushEnabled(playerId);
+        const stats = await enhancedNotifications.getPlayerStats(playerId);
+
+        res.json({
+            success: true,
+            pushEnabled: isEnabled,
+            playerStats: stats
+        });
+    } catch (error) {
+        console.error('Error getting player push status:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen des Push-Status'
+        });
+    }
+});
+
+// Get current player ID for logged in user
+router.get('/v1/public/current-player', async (req, res) => {
+    try {
+        const userId = req.session.userId;
+
+        if (!userId || userId === 'anonymous') {
+            return res.json({
+                success: false,
+                message: 'No logged in user'
+            });
+        }
+
+        // Get player ID from database
+        const result = await pool.query(
+            'SELECT id FROM players WHERE supabase_user_id = $1',
+            [userId]
+        );
+
+        if (result.rows.length > 0) {
+            res.json({
+                success: true,
+                playerId: result.rows[0].id
+            });
+        } else {
+            res.json({
+                success: false,
+                message: 'No player record found for user'
+            });
+        }
+    } catch (error) {
+        console.error('Error getting current player:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der Player-ID'
+        });
+    }
+});
+
+// Subscribe to push notifications
+router.post('/v1/public/subscribe', async (req, res) => {
+    try {
+        console.log('📱 Push subscription request received:', JSON.stringify(req.body, null, 2));
+
+        const { endpoint, keys, playerId: requestPlayerId, supabaseUserId } = req.body;
+        const userId = req.session.userId || supabaseUserId || 'anonymous';
+
+        // Validate required fields
+        if (!endpoint) {
+            console.error('❌ Missing endpoint in request');
+            return res.status(400).json({
+                success: false,
+                message: 'Endpoint ist erforderlich'
+            });
+        }
+
+        if (!keys || !keys.p256dh || !keys.auth) {
+            console.error('❌ Missing keys in request:', keys);
+            return res.status(400).json({
+                success: false,
+                message: 'Push-Keys sind erforderlich'
+            });
+        }
+
+        // Get player ID from logged-in user's supabase_user_id or create anonymous player
+        let playerId;
+        if (userId === 'anonymous') {
+            // For anonymous users, create a temporary player profile
+            console.log('📱 Anonymous user detected, creating temporary player profile...');
+            try {
+                const createResult = await pool.query(
+                    'INSERT INTO players (supabase_user_id, firstname, lastname, birthdate, created_at) VALUES ($1, $2, $3, $4, NOW()) RETURNING id',
+                    [null, 'Anonymer', 'Benutzer', '1990-01-01']
+                );
+                playerId = createResult.rows[0].id;
+                console.log(`📱 Created temporary player profile for anonymous user: ${playerId}`);
+            } catch (error) {
+                console.error('Error creating anonymous player:', error);
+                return res.status(500).json({
+                    success: false,
+                    message: 'Fehler beim Erstellen des temporären Spieler-Profils'
+                });
+            }
+        } else {
+            // For logged in users, get their player ID from database or create one
+            try {
+                const playerResult = await pool.query(
+                    'SELECT id FROM players WHERE supabase_user_id = $1',
+                    [userId]
+                );
+                if (playerResult.rows.length > 0) {
+                    playerId = playerResult.rows[0].id;
+                    console.log(`📱 Found existing player ID for user ${userId}: ${playerId}`);
+                } else {
+                    // Create new player profile automatically
+                    console.log(`📱 No player profile found for user ${userId}, creating new one...`);
+                    const createResult = await pool.query(
+                        'INSERT INTO players (supabase_user_id, firstname, lastname, birthdate, created_at) VALUES ($1, $2, $3, $4, NOW()) RETURNING id',
+                        [userId, 'Unbekannt', 'Benutzer', '1990-01-01']
+                    );
+                    playerId = createResult.rows[0].id;
+                    console.log(`📱 Created new player profile for user ${userId}: ${playerId}`);
+                }
+            } catch (error) {
+                console.error('Error looking up or creating player ID:', error);
+                return res.status(500).json({
+                    success: false,
+                    message: 'Fehler beim Abrufen oder Erstellen der Player-ID'
+                });
+            }
+        }
+
+        console.log(`📱 Processing subscription for player: ${playerId}`);
+
+        // Store subscription in database with new structure
+        await pool.query(`
+            INSERT INTO player_subscriptions (player_id, endpoint, p256dh, auth, created_at)
+            VALUES ($1, $2, $3, $4, NOW())
+        `, [
+            playerId,
+            endpoint,
+            keys.p256dh,
+            keys.auth
+        ]);
+
+        // Also store in push service for immediate use
+        const subscription = {
+            endpoint: endpoint,
+            keys: {
+                p256dh: keys.p256dh,
+                auth: keys.auth
+            }
+        };
+        pushService.subscribe(playerId, subscription);
+
+        res.json({
+            success: true,
+            message: 'Push subscription erfolgreich gespeichert',
+            playerId: playerId,
+            pushId: 'generated' // Will be generated by database
+        });
+    } catch (error) {
+        console.error('Error storing push subscription:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Speichern der Push Subscription',
+            error: error.message
+        });
+    }
+});
+
+// Unsubscribe from push notifications
+router.post('/v1/public/unsubscribe', async (req, res) => {
+    try {
+        const { endpoint, playerId } = req.body;
+        const userId = req.session.userId || 'anonymous';
+
+        // Validate required fields
+        if (!endpoint) {
+            return res.status(400).json({
+                success: false,
+                message: 'Endpoint erforderlich'
+            });
+        }
+
+        // For anonymous users, we need the playerId to be provided
+        if (userId === 'anonymous' && !playerId) {
+            return res.status(400).json({
+                success: false,
+                message: 'Player ID erforderlich für anonyme Benutzer'
+            });
+        }
+
+        // Get player ID from logged-in user
+        let actualPlayerId = playerId;
+        if (!actualPlayerId) {
+            try {
+                const playerResult = await pool.query(
+                    'SELECT id FROM players WHERE supabase_user_id = $1',
+                    [userId]
+                );
+                if (playerResult.rows.length > 0) {
+                    actualPlayerId = playerResult.rows[0].id;
+                } else {
+                    return res.status(404).json({
+                        success: false,
+                        message: 'Kein Spieler-Profil gefunden'
+                    });
+                }
+            } catch (error) {
+                console.error('Error looking up player ID:', error);
+                return res.status(500).json({
+                    success: false,
+                    message: 'Fehler beim Abrufen der Player-ID'
+                });
+            }
+        }
+
+        // Remove specific subscription from database (by endpoint)
+        const result = await pool.query(`
+            DELETE FROM player_subscriptions 
+            WHERE player_id = $1 AND endpoint = $2
+        `, [actualPlayerId, endpoint]);
+
+        // Remove specific subscription from push service
+        pushService.unsubscribeDevice(actualPlayerId, endpoint);
+
+        console.log(`Device ${endpoint} unsubscribed from push notifications for player ${actualPlayerId} (${result.rowCount} subscriptions removed)`);
+
+        res.json({
+            success: true,
+            message: `${result.rowCount} Push subscription(s) erfolgreich entfernt`
+        });
+    } catch (error) {
+        console.error('Error removing push subscription:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Entfernen der Push Subscription'
+        });
+    }
+});
+
+// Test push notification endpoint
+router.post('/v1/public/test-push', async (req, res) => {
+    try {
+        const { userId, message } = req.body;
+
+        const payload = {
+            title: '🧪 Test Notification',
+            body: message || 'Das ist eine Test-Push-Notification!',
+            icon: '/pictures/icon-192.png',
+            badge: '/pictures/icon-192.png',
+            data: {
+                type: 'test',
+                timestamp: Date.now()
+            }
+        };
+
+        const success = await pushService.sendToUser(userId || 'anonymous', payload);
+
+        res.json({
+            success: success,
+            message: success ? 'Test-Push gesendet!' : 'Keine Subscription gefunden'
+        });
+    } catch (error) {
+        console.error('Error sending test push:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Senden der Test-Push'
+        });
+    }
+});
+
+// Get push subscription status
+router.get('/v1/public/push-status', async (req, res) => {
+    try {
+        const userId = req.session.userId || 'anonymous';
+
+        // For anonymous users, we can't check specific subscription
+        // but we can show general stats
+        const hasSubscription = userId !== 'anonymous' ? pushService.subscriptions.has(userId) : false;
+
+        res.json({
+            success: true,
+            data: {
+                hasSubscription: hasSubscription,
+                totalSubscriptions: pushService.getSubscriptionCount(),
+                subscribedUsers: pushService.getSubscribedUsers(),
+                isAnonymous: userId === 'anonymous'
+            }
+        });
+    } catch (error) {
+        console.error('Error getting push status:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen des Push-Status'
+        });
+    }
+});
+
+// Check if notification was already sent today
+router.get('/v1/public/notification-sent/:playerId/:type', async (req, res) => {
+    try {
+        const { playerId, type } = req.params;
+        const { achievementId, locationId } = req.query;
+
+        // Validate required parameters
+        if (!playerId || playerId === 'undefined' || playerId === 'null') {
+            return res.status(400).json({
+                success: false,
+                message: 'Player ID ist erforderlich'
+            });
+        }
+
+        if (!type) {
+            return res.status(400).json({
+                success: false,
+                message: 'Notification Type ist erforderlich'
+            });
+        }
+
+        // Validate achievementId if provided
+        if (achievementId && (achievementId === 'undefined' || achievementId === 'null')) {
+            return res.status(400).json({
+                success: false,
+                message: 'Ungültige Achievement ID'
+            });
+        }
+
+        const today = new Date().toISOString().split('T')[0];
+
+        const result = await pool.query(`
+            SELECT COUNT(*) as count
+            FROM sent_notifications 
+            WHERE player_id = $1 
+            AND notification_type = $2
+            AND (achievement_id = $3 OR ($3 IS NULL AND achievement_id IS NULL))
+            AND (location_id = $4 OR ($4 IS NULL AND location_id IS NULL))
+            AND DATE(sent_at) = $5
+        `, [playerId, type, achievementId || null, locationId || null, today]);
+
+        const wasSent = parseInt(result.rows[0].count) > 0;
+
+        res.json({
+            success: true,
+            wasSent: wasSent
+        });
+    } catch (error) {
+        console.error('Error checking notification status:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Prüfen des Notification-Status'
+        });
+    }
+});
+
+// Mark notification as sent
+router.post('/v1/public/notification-sent', async (req, res) => {
+    try {
+        const { playerId, notificationType, achievementId, locationId } = req.body;
+
+        // Log notification details to server console
+        const logData = {
+            playerId: playerId,
+            notificationType: notificationType,
+            timestamp: new Date().toISOString()
+        };
+
+        // Only add achievementId and locationId if they exist
+        if (achievementId) logData.achievementId = achievementId;
+        if (locationId) logData.locationId = locationId;
+
+        console.log('📱 Push Notification marked as sent:', logData);
+
+        await pool.query(`
+            INSERT INTO sent_notifications (player_id, notification_type, achievement_id, location_id)
+            VALUES ($1, $2, $3, $4)
+            ON CONFLICT DO NOTHING
+        `, [playerId, notificationType, achievementId || null, locationId || null]);
+
+        res.json({
+            success: true,
+            message: 'Notification als gesendet markiert'
+        });
+    } catch (error) {
+        console.error('Error marking notification as sent:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Markieren der Notification'
+        });
+    }
+});
+
+// ==================== ANALYTICS HELPER FUNCTIONS ====================
+
+async function getPerformanceTrends(playerId) {
+    const now = new Date();
+    const startOfWeek = new Date(now.setDate(now.getDate() - now.getDay()));
+    const startOfLastWeek = new Date(startOfWeek.getTime() - 7 * 24 * 60 * 60 * 1000);
+
+    // This week's average
+    const thisWeekResult = await pool.query(`
+        SELECT AVG(EXTRACT(EPOCH FROM recorded_time)) as avg_seconds
+        FROM times 
+        WHERE player_id = $1 
+        AND created_at >= $2
+    `, [playerId, startOfWeek]);
+
+    // Last week's average
+    const lastWeekResult = await pool.query(`
+        SELECT AVG(EXTRACT(EPOCH FROM recorded_time)) as avg_seconds
+        FROM times 
+        WHERE player_id = $1 
+        AND created_at >= $2 AND created_at < $3
+    `, [playerId, startOfLastWeek, startOfWeek]);
+
+    const avgTimeThisWeek = thisWeekResult.rows[0].avg_seconds || 0;
+    const avgTimeLastWeek = lastWeekResult.rows[0].avg_seconds || 0;
+
+    const improvement = avgTimeLastWeek > 0 ?
+        ((avgTimeLastWeek - avgTimeThisWeek) / avgTimeLastWeek * 100) : 0;
+
+    return {
+        avgTimeThisWeek: Math.round(avgTimeThisWeek * 100) / 100,
+        avgTimeLastWeek: Math.round(avgTimeLastWeek * 100) / 100,
+        improvement: Math.round(improvement * 100) / 100
+    };
+}
+
+async function getActivityStats(playerId) {
+    const now = new Date();
+    const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const startOfWeek = new Date(now.setDate(now.getDate() - now.getDay()));
+
+    // Today's runs
+    const todayResult = await pool.query(`
+        SELECT COUNT(*) as count
+        FROM times 
+        WHERE player_id = $1 
+        AND created_at >= $2
+    `, [playerId, startOfDay]);
+
+    // This week's runs
+    const weekResult = await pool.query(`
+        SELECT COUNT(*) as count
+        FROM times 
+        WHERE player_id = $1 
+        AND created_at >= $2
+    `, [playerId, startOfWeek]);
+
+    // Average runs per day (last 30 days)
+    const avgResult = await pool.query(`
+        SELECT COUNT(*) / 30.0 as avg_runs
+        FROM times 
+        WHERE player_id = $1 
+        AND created_at >= NOW() - INTERVAL '30 days'
+    `, [playerId]);
+
+    return {
+        runsToday: parseInt(todayResult.rows[0].count),
+        runsThisWeek: parseInt(weekResult.rows[0].count),
+        avgRunsPerDay: Math.round((parseFloat(avgResult.rows[0].avg_runs) || 0) * 100) / 100
+    };
+}
+
+async function getLocationPerformance(playerId) {
+    const result = await pool.query(`
+        SELECT 
+            l.name,
+            MIN(t.recorded_time) as best_time,
+            COUNT(t.id) as runs
+        FROM times t
+        JOIN locations l ON t.location_id = l.id
+        WHERE t.player_id = $1
+        GROUP BY l.id, l.name
+        ORDER BY best_time ASC
+        LIMIT 10
+    `, [playerId]);
+
+    return result.rows.map(row => ({
+        name: row.name,
+        bestTime: Math.round(convertTimeToSeconds(row.best_time) * 100) / 100,
+        runs: parseInt(row.runs)
+    }));
+}
+
+async function getMonthlyStats(playerId) {
+    const now = new Date();
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+    const startOfLastMonth = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+    const endOfLastMonth = new Date(now.getFullYear(), now.getMonth(), 0);
+
+    // This month's runs
+    const thisMonthResult = await pool.query(`
+        SELECT COUNT(*) as count
+        FROM times 
+        WHERE player_id = $1 
+        AND created_at >= $2
+    `, [playerId, startOfMonth]);
+
+    // Last month's runs
+    const lastMonthResult = await pool.query(`
+        SELECT COUNT(*) as count
+        FROM times 
+        WHERE player_id = $1 
+        AND created_at >= $2 AND created_at <= $3
+    `, [playerId, startOfLastMonth, endOfLastMonth]);
+
+    // Best time this month
+    const bestTimeResult = await pool.query(`
+        SELECT MIN(recorded_time) as best_time
+        FROM times 
+        WHERE player_id = $1 
+        AND created_at >= $2
+    `, [playerId, startOfMonth]);
+
+    return {
+        runsThisMonth: parseInt(thisMonthResult.rows[0].count),
+        runsLastMonth: parseInt(lastMonthResult.rows[0].count),
+        bestTimeThisMonth: Math.round((convertTimeToSeconds(bestTimeResult.rows[0].best_time) || 0) * 100) / 100
+    };
+}
+
+async function getPersonalRecords(playerId) {
+    const result = await pool.query(`
+        SELECT 
+            t.recorded_time,
+            l.name as location
+        FROM times t
+        JOIN locations l ON t.location_id = l.id
+        WHERE t.player_id = $1
+        ORDER BY t.recorded_time ASC
+        LIMIT 5
+    `, [playerId]);
+
+    return result.rows.map(row => ({
+        time: Math.round(convertTimeToSeconds(row.recorded_time) * 100) / 100,
+        location: row.location
+    }));
+}
+
+async function getConsistencyMetrics(playerId) {
+    const result = await pool.query(`
+        SELECT 
+            AVG(EXTRACT(EPOCH FROM recorded_time)) as avg_seconds,
+            STDDEV(EXTRACT(EPOCH FROM recorded_time)) as stddev_seconds
+        FROM times 
+        WHERE player_id = $1
+    `, [playerId]);
+
+    const avgSeconds = parseFloat(result.rows[0].avg_seconds) || 0;
+    const stddevSeconds = parseFloat(result.rows[0].stddev_seconds) || 0;
+
+    // Consistency score: lower deviation = higher consistency
+    const consistencyScore = avgSeconds > 0 ?
+        Math.max(0, Math.min(100, (1 - (stddevSeconds / avgSeconds)) * 100)) : 0;
+
+    return {
+        averageTime: Math.round(avgSeconds * 100) / 100,
+        timeDeviation: Math.round(stddevSeconds * 100) / 100,
+        consistencyScore: Math.round(consistencyScore * 100) / 100
+    };
+}
+
+async function getRankingStats(playerId) {
+    // Get player's best time
+    const bestTimeResult = await pool.query(`
+        SELECT MIN(recorded_time) as best_time
+        FROM times 
+        WHERE player_id = $1
+    `, [playerId]);
+
+    const bestTime = bestTimeResult.rows[0].best_time;
+    if (!bestTime) {
+        return [];
+    }
+
+    // Get rankings for different categories
+    const rankings = [];
+
+    // Overall ranking
+    const overallResult = await pool.query(`
+        SELECT COUNT(*) + 1 as position
+        FROM times 
+        WHERE recorded_time < $1
+    `, [bestTime]);
+
+    const totalPlayersResult = await pool.query(`
+        SELECT COUNT(DISTINCT player_id) as total
+        FROM times
+    `);
+
+    rankings.push({
+        category: 'Gesamt',
+        position: parseInt(overallResult.rows[0].position),
+        total: parseInt(totalPlayersResult.rows[0].total)
+    });
+
+    return rankings;
+}
+
+async function getProgressStats(playerId) {
+    // Total runs
+    const totalRunsResult = await pool.query(`
+        SELECT COUNT(*) as count
+        FROM times 
+        WHERE player_id = $1
+    `, [playerId]);
+
+    // Active days
+    const activeDaysResult = await pool.query(`
+        SELECT COUNT(DISTINCT DATE(created_at)) as count
+        FROM times 
+        WHERE player_id = $1
+    `, [playerId]);
+
+    // Locations visited
+    const locationsResult = await pool.query(`
+        SELECT COUNT(DISTINCT location_id) as count
+        FROM times 
+        WHERE player_id = $1
+    `, [playerId]);
+
+    return {
+        totalRuns: parseInt(totalRunsResult.rows[0].count),
+        activeDays: parseInt(activeDaysResult.rows[0].count),
+        locationsVisited: parseInt(locationsResult.rows[0].count)
+    };
+}
+
+// ==================== ANALYTICS ENDPOINTS ====================
+
+/**
+ * @swagger
+ * /api/analytics/player/{playerId}:
+ *   get:
+ *     summary: Analytics-Daten für einen Spieler abrufen
+ *     description: Ruft detaillierte Analytics-Daten für einen bestimmten Spieler ab
+ *     tags: [Analytics]
+ *     parameters:
+ *       - in: path
+ *         name: playerId
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: Spieler-ID
+ *     responses:
+ *       200:
+ *         description: Analytics-Daten erfolgreich abgerufen
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                 data:
+ *                   type: object
+ *       404:
+ *         description: Spieler nicht gefunden
+ *       500:
+ *         description: Interner Serverfehler
+ */
+router.get('/analytics/player/:playerId', async (req, res) => {
+    const { playerId } = req.params;
+
+    try {
+        // Performance Trends
+        const performanceData = await getPerformanceTrends(playerId);
+
+        // Activity Stats
+        const activityData = await getActivityStats(playerId);
+
+        // Location Performance
+        const locationData = await getLocationPerformance(playerId);
+
+        // Monthly Stats
+        const monthlyData = await getMonthlyStats(playerId);
+
+        const analyticsData = {
+            performance: performanceData,
+            activity: activityData,
+            locationPerformance: locationData,
+            monthly: monthlyData
+        };
+
+        res.json({
+            success: true,
+            data: analyticsData
+        });
+
+    } catch (error) {
+        console.error('Error fetching analytics data:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Analytics-Daten'
+        });
+    }
+});
+
+// ==================== STATISTICS ENDPOINTS ====================
+
+/**
+ * @swagger
+ * /api/statistics/player/{playerId}:
+ *   get:
+ *     summary: Statistiken für einen Spieler abrufen
+ *     description: Ruft detaillierte Statistiken für einen bestimmten Spieler ab
+ *     tags: [Statistics]
+ *     parameters:
+ *       - in: path
+ *         name: playerId
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: Spieler-ID
+ *     responses:
+ *       200:
+ *         description: Statistiken erfolgreich abgerufen
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                 data:
+ *                   type: object
+ *       404:
+ *         description: Spieler nicht gefunden
+ *       500:
+ *         description: Interner Serverfehler
+ */
+router.get('/statistics/player/:playerId', async (req, res) => {
+    const { playerId } = req.params;
+
+    try {
+        // Personal Records
+        const personalRecords = await getPersonalRecords(playerId);
+
+        // Consistency Metrics
+        const consistencyData = await getConsistencyMetrics(playerId);
+
+        // Ranking Stats
+        const rankingData = await getRankingStats(playerId);
+
+        // Progress Stats
+        const progressData = await getProgressStats(playerId);
+
+        const statisticsData = {
+            personalRecords: personalRecords,
+            consistency: consistencyData,
+            rankings: rankingData,
+            progress: progressData
+        };
+
+        res.json({
+            success: true,
+            data: statisticsData
+        });
+
+    } catch (error) {
+        console.error('Error fetching statistics data:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Statistiken'
+        });
+    }
+});
+
+// ==================== ACHIEVEMENT ENDPOINTS ====================
+
+/**
+ * @swagger
+ * /api/achievements:
+ *   get:
+ *     summary: Alle verfügbaren Achievements abrufen
+ *     description: Ruft alle aktiven Achievements im System ab
+ *     tags: [Achievements]
+ *     responses:
+ *       200:
+ *         description: Liste aller Achievements
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 data:
+ *                   type: array
+ *                   items:
+ *                     $ref: '#/components/schemas/Achievement'
+ *       500:
+ *         description: Server-Fehler
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/Error'
+ */
+// Get all achievements
+router.get('/achievements', async (req, res) => {
+    try {
+        const result = await pool.query(`
+            SELECT id, name, name_en, description, description_en, category, icon, points, is_active
+            FROM achievements 
+            WHERE is_active = true
+            ORDER BY category, points DESC
+        `);
+
+        res.json({
+            success: true,
+            data: result.rows
+        });
+    } catch (error) {
+        console.error('Error fetching achievements:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Achievements'
+        });
+    }
+});
+
+/**
+ * @swagger
+ * /api/achievements/player/{playerId}:
+ *   get:
+ *     summary: Achievements eines Spielers abrufen
+ *     description: Ruft alle Achievements für einen bestimmten Spieler ab
+ *     tags: [Achievements]
+ *     parameters:
+ *       - in: path
+ *         name: playerId
+ *         required: true
+ *         schema:
+ *           type: string
+ *           format: uuid
+ *         description: Eindeutige Spieler-ID
+ *     responses:
+ *       200:
+ *         description: Liste der Spieler-Achievements
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 data:
+ *                   type: array
+ *                   items:
+ *                     allOf:
+ *                       - $ref: '#/components/schemas/Achievement'
+ *                       - $ref: '#/components/schemas/PlayerAchievement'
+ *       500:
+ *         description: Server-Fehler
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/Error'
+ */
+// Get player achievements
+router.get('/achievements/player/:playerId', async (req, res) => {
+    try {
+        // Set no-cache headers
+        res.set({
+            'Cache-Control': 'no-cache, no-store, must-revalidate',
+            'Pragma': 'no-cache',
+            'Expires': '0'
+        });
+
+        const { playerId } = req.params;
+
+        const result = await pool.query(`
+            SELECT 
+                a.id,
+                a.name,
+                a.name_en,
+                a.description,
+                a.description_en,
+                a.category,
+                a.icon,
+                a.points,
+                COALESCE(MAX(pa.progress), 0) as progress,
+                COALESCE(COUNT(pa.id) > 0, false) as is_completed,
+                MAX(pa.earned_at) as earned_at,
+                COUNT(pa.id) as completion_count
+            FROM achievements a
+            LEFT JOIN player_achievements pa ON a.id = pa.achievement_id AND pa.player_id = $1
+            WHERE a.is_active = true
+            GROUP BY a.id, a.name, a.name_en, a.description, a.description_en, a.category, a.icon, a.points
+            ORDER BY 
+                COALESCE(COUNT(pa.id) > 0, false) DESC,
+                a.category,
+                a.points DESC
+        `, [playerId]);
+
+        res.json({
+            success: true,
+            data: result.rows
+        });
+    } catch (error) {
+        console.error('Error fetching player achievements:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Spieler-Achievements'
+        });
+    }
+});
+
+// Get player achievement statistics
+router.get('/achievements/player/:playerId/stats', async (req, res) => {
+    try {
+        // Set no-cache headers
+        res.set({
+            'Cache-Control': 'no-cache, no-store, must-revalidate',
+            'Pragma': 'no-cache',
+            'Expires': '0'
+        });
+
+        const { playerId } = req.params;
+
+        // Get total available achievements
+        const totalResult = await pool.query(`
+            SELECT COUNT(*) as total_achievements
+            FROM achievements 
+            WHERE is_active = true
+        `);
+
+        // Get player's earned achievements (count unique achievements, not total completions)
+        const playerResult = await pool.query(`
+            SELECT 
+                COUNT(DISTINCT CASE WHEN pa.is_completed = true THEN pa.achievement_id END) as completed_achievements,
+                SUM(CASE WHEN pa.is_completed = true THEN a.points ELSE 0 END) as total_points,
+                COUNT(CASE WHEN pa.is_completed = true AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE THEN 1 END) as achievements_today
+            FROM achievements a
+            LEFT JOIN player_achievements pa ON a.id = pa.achievement_id AND pa.player_id = $1
+            WHERE a.is_active = true
+        `, [playerId]);
+
+        const totalStats = totalResult.rows[0];
+        const playerStats = playerResult.rows[0];
+
+        const totalAchievements = parseInt(totalStats.total_achievements);
+        const completedAchievements = parseInt(playerStats.completed_achievements) || 0;
+        const completionPercentage = totalAchievements > 0 ? Math.round((completedAchievements / totalAchievements) * 100) : 0;
+
+        res.json({
+            success: true,
+            data: {
+                total_achievements: totalAchievements,
+                completed_achievements: completedAchievements,
+                total_points: parseInt(playerStats.total_points) || 0,
+                achievements_today: parseInt(playerStats.achievements_today) || 0,
+                completion_percentage: completionPercentage
+            }
+        });
+    } catch (error) {
+        console.error('Error fetching player achievement stats:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Achievement-Statistiken'
+        });
+    }
+});
+
+// Check achievements for a specific player
+router.post('/achievements/check/:playerId', async (req, res) => {
+    try {
+        const { playerId } = req.params;
+
+        // Verify player exists
+        const playerCheck = await pool.query('SELECT id FROM players WHERE id = $1', [playerId]);
+        if (playerCheck.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Spieler nicht gefunden'
+            });
+        }
+
+        // Run achievement check using AchievementSystem
+        const AchievementSystem = require('../lib/achievementSystem');
+        const achievementSystem = new AchievementSystem();
+        await achievementSystem.loadAchievements();
+        const newAchievementsFromCheck = await achievementSystem.checkAllAchievements(playerId);
+
+        // Get newly earned achievements
+        const newAchievements = await pool.query(`
+            SELECT a.name, a.description, a.icon, a.points
+            FROM player_achievements pa
+            INNER JOIN achievements a ON pa.achievement_id = a.id
+            WHERE pa.player_id = $1 
+            AND pa.is_completed = true
+            AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+            ORDER BY pa.earned_at DESC
+        `, [playerId]);
+
+        res.json({
+            success: true,
+            message: 'Achievement-Check abgeschlossen',
+            data: {
+                new_achievements: newAchievements.rows,
+                count: newAchievements.rows.length
+            }
+        });
+    } catch (error) {
+        console.error('Error checking achievements:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Überprüfen der Achievements'
+        });
+    }
+});
+
+// Run daily achievement check for all players
+router.post('/achievements/daily-check', async (req, res) => {
+    try {
+        // This endpoint runs the daily achievement check
+        const { runDailyAchievements } = require('../scripts/daily_achievements');
+
+        await runDailyAchievements();
+
+        res.json({
+            success: true,
+            message: 'Tägliche Achievement-Überprüfung abgeschlossen'
+        });
+    } catch (error) {
+        console.error('Error running daily achievement check:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler bei der täglichen Achievement-Überprüfung'
+        });
+    }
+});
+
+// Run best-time achievement check (for manual testing or cron jobs)
+router.post('/achievements/best-time-check', async (req, res) => {
+    try {
+        // This endpoint runs the best-time achievement check
+        const { runBestTimeAchievements } = require('../scripts/best_time_achievements');
+
+        await runBestTimeAchievements();
+
+        res.json({
+            success: true,
+            message: 'Best-Time Achievement-Überprüfung abgeschlossen'
+        });
+    } catch (error) {
+        console.error('Error running best-time achievement check:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler bei der Best-Time Achievement-Überprüfung'
+        });
+    }
+});
+
+// Get achievement leaderboard
+router.get('/achievements/leaderboard', async (req, res) => {
+    try {
+        const { limit = 10 } = req.query;
+
+        const result = await pool.query(`
+            SELECT 
+                p.firstname,
+                p.lastname,
+                COUNT(pa.id) as completed_achievements,
+                SUM(a.points) as total_points
+            FROM players p
+            INNER JOIN player_achievements pa ON p.id = pa.player_id
+            INNER JOIN achievements a ON pa.achievement_id = a.id
+            WHERE pa.is_completed = true
+            GROUP BY p.id, p.firstname, p.lastname
+            ORDER BY total_points DESC, completed_achievements DESC
+            LIMIT $1
+        `, [parseInt(limit)]);
+
+        res.json({
+            success: true,
+            data: result.rows.map((row, index) => ({
+                rank: index + 1,
+                name: `${row.firstname} ${row.lastname}`,
+                completed_achievements: parseInt(row.completed_achievements),
+                total_points: parseInt(row.total_points)
+            }))
+        });
+    } catch (error) {
+        console.error('Error fetching achievement leaderboard:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Bestenliste'
+        });
+    }
+});
+
+// Update player settings (privacy settings) - Public endpoint for authenticated users
+router.post('/v1/public/update-player-settings', async (req, res) => {
+    try {
+        const { player_id, show_in_leaderboard } = req.body;
+
+        if (!player_id) {
+            return res.status(400).json({
+                success: false,
+                message: 'Player ID ist erforderlich'
+            });
+        }
+
+        // Update player settings
+        const updateQuery = `
+            UPDATE players 
+            SET show_in_leaderboard = $1, updated_at = NOW()
+            WHERE id = $2
+            RETURNING id, firstname, lastname, show_in_leaderboard
+        `;
+
+        const result = await pool.query(updateQuery, [show_in_leaderboard || false, player_id]);
+
+        if (result.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Spieler nicht gefunden'
+            });
+        }
+
+        res.json({
+            success: true,
+            message: 'Einstellungen erfolgreich aktualisiert',
+            data: result.rows[0]
+        });
+
+    } catch (error) {
+        console.error('Error updating player settings:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Aktualisieren der Einstellungen'
+        });
+    }
+});
+
+// Update player settings (privacy settings) - Private endpoint with API key
+router.post('/v1/private/update-player-settings', requireApiKey, async (req, res) => {
+    try {
+        const { player_id, show_in_leaderboard } = req.body;
+
+        if (!player_id) {
+            return res.status(400).json({
+                success: false,
+                message: 'Player ID ist erforderlich'
+            });
+        }
+
+        // Update player settings
+        const updateQuery = `
+            UPDATE players 
+            SET show_in_leaderboard = $1, updated_at = NOW()
+            WHERE id = $2
+            RETURNING id, firstname, lastname, show_in_leaderboard
+        `;
+
+        const result = await pool.query(updateQuery, [show_in_leaderboard || false, player_id]);
+
+        if (result.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Spieler nicht gefunden'
+            });
+        }
+
+        res.json({
+            success: true,
+            message: 'Einstellungen erfolgreich aktualisiert',
+            data: result.rows[0]
+        });
+
+    } catch (error) {
+        console.error('Error updating player settings:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Aktualisieren der Einstellungen'
+        });
+    }
+});
+
+// ==================== ADMIN ACHIEVEMENT MANAGEMENT ====================
+
+/**
+ * @swagger
+ * /api/admin/achievements:
+ *   get:
+ *     summary: Alle Achievements für Admin-Verwaltung abrufen
+ *     description: Ruft alle Achievements (aktiv und inaktiv) für die Admin-Verwaltung ab
+ *     tags: [Admin, Achievements]
+ *     responses:
+ *       200:
+ *         description: Liste aller Achievements
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 data:
+ *                   type: array
+ *                   items:
+ *                     $ref: '#/components/schemas/Achievement'
+ *       500:
+ *         description: Server-Fehler
+ */
+// Get all achievements for admin management
+router.get('/v1/admin/achievements', requireAdminAuth, async (req, res) => {
+    try {
+        const result = await pool.query(`
+            SELECT 
+                id, name, name_en, description, description_en, category, 
+                condition_type, condition_value, icon, points, is_active, 
+                can_be_earned_multiple_times, created_at
+            FROM achievements 
+            ORDER BY is_active DESC, category, points DESC
+        `);
+
+        res.json({
+            success: true,
+            data: result.rows
+        });
+    } catch (error) {
+        console.error('Error fetching achievements for admin:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Achievements'
+        });
+    }
+});
+
+/**
+ * @swagger
+ * /api/admin/achievements:
+ *   post:
+ *     summary: Neues Achievement erstellen
+ *     description: Erstellt ein neues Achievement im System
+ *     tags: [Admin, Achievements]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - name
+ *               - description
+ *               - category
+ *               - condition_type
+ *               - condition_value
+ *             properties:
+ *               name:
+ *                 type: string
+ *                 description: Name des Achievements
+ *               name_en:
+ *                 type: string
+ *                 description: Englischer Name des Achievements
+ *               description:
+ *                 type: string
+ *                 description: Beschreibung des Achievements
+ *               description_en:
+ *                 type: string
+ *                 description: Englische Beschreibung des Achievements
+ *               category:
+ *                 type: string
+ *                 description: Kategorie des Achievements
+ *               condition_type:
+ *                 type: string
+ *                 description: Art der Bedingung
+ *               condition_value:
+ *                 type: integer
+ *                 description: Wert der Bedingung
+ *               icon:
+ *                 type: string
+ *                 description: Icon für das Achievement
+ *               points:
+ *                 type: integer
+ *                 description: Punkte für das Achievement
+ *               is_active:
+ *                 type: boolean
+ *                 description: Ob das Achievement aktiv ist
+ *               can_be_earned_multiple_times:
+ *                 type: boolean
+ *                 description: Ob das Achievement mehrmals erreicht werden kann
+ *     responses:
+ *       201:
+ *         description: Achievement erfolgreich erstellt
+ *       400:
+ *         description: Ungültige Eingabedaten
+ *       500:
+ *         description: Server-Fehler
+ */
+// Create new achievement
+router.post('/v1/admin/achievements', requireAdminAuth, async (req, res) => {
+    try {
+        const {
+            name, name_en, description, description_en, category,
+            condition_type, condition_value, icon, points, is_active,
+            can_be_earned_multiple_times
+        } = req.body;
+
+        // Validate required fields
+        if (!name || !description || !category || !condition_type || condition_value === undefined) {
+            return res.status(400).json({
+                success: false,
+                message: 'Name, Beschreibung, Kategorie, Bedingungstyp und Bedingungswert sind erforderlich'
+            });
+        }
+
+        const result = await pool.query(`
+            INSERT INTO achievements (
+                name, name_en, description, description_en, category,
+                condition_type, condition_value, icon, points, is_active,
+                can_be_earned_multiple_times
+            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+            RETURNING *
+        `, [
+            name, name_en || null, description, description_en || null, category,
+            condition_type, condition_value, icon || '🏆', points || 10,
+            is_active !== false, can_be_earned_multiple_times || false
+        ]);
+
+        res.status(201).json({
+            success: true,
+            message: 'Achievement erfolgreich erstellt',
+            data: result.rows[0]
+        });
+    } catch (error) {
+        console.error('Error creating achievement:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Erstellen des Achievements'
+        });
+    }
+});
+
+/**
+ * @swagger
+ * /api/admin/achievements/{id}:
+ *   put:
+ *     summary: Achievement aktualisieren
+ *     description: Aktualisiert ein bestehendes Achievement
+ *     tags: [Admin, Achievements]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *           format: uuid
+ *         description: ID des Achievements
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               name:
+ *                 type: string
+ *               name_en:
+ *                 type: string
+ *               description:
+ *                 type: string
+ *               description_en:
+ *                 type: string
+ *               category:
+ *                 type: string
+ *               condition_type:
+ *                 type: string
+ *               condition_value:
+ *                 type: integer
+ *               icon:
+ *                 type: string
+ *               points:
+ *                 type: integer
+ *               is_active:
+ *                 type: boolean
+ *               can_be_earned_multiple_times:
+ *                 type: boolean
+ *     responses:
+ *       200:
+ *         description: Achievement erfolgreich aktualisiert
+ *       404:
+ *         description: Achievement nicht gefunden
+ *       500:
+ *         description: Server-Fehler
+ */
+// Update achievement
+router.put('/v1/admin/achievements/:id', requireAdminAuth, async (req, res) => {
+    try {
+        const { id } = req.params;
+        const {
+            name, name_en, description, description_en, category,
+            condition_type, condition_value, icon, points, is_active,
+            can_be_earned_multiple_times
+        } = req.body;
+
+        const result = await pool.query(`
+            UPDATE achievements SET
+                name = COALESCE($2, name),
+                name_en = COALESCE($3, name_en),
+                description = COALESCE($4, description),
+                description_en = COALESCE($5, description_en),
+                category = COALESCE($6, category),
+                condition_type = COALESCE($7, condition_type),
+                condition_value = COALESCE($8, condition_value),
+                icon = COALESCE($9, icon),
+                points = COALESCE($10, points),
+                is_active = COALESCE($11, is_active),
+                can_be_earned_multiple_times = COALESCE($12, can_be_earned_multiple_times)
+            WHERE id = $1
+            RETURNING *
+        `, [
+            id, name, name_en, description, description_en, category,
+            condition_type, condition_value, icon, points, is_active,
+            can_be_earned_multiple_times
+        ]);
+
+        if (result.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Achievement nicht gefunden'
+            });
+        }
+
+        res.json({
+            success: true,
+            message: 'Achievement erfolgreich aktualisiert',
+            data: result.rows[0]
+        });
+    } catch (error) {
+        console.error('Error updating achievement:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Aktualisieren des Achievements'
+        });
+    }
+});
+
+/**
+ * @swagger
+ * /api/admin/achievements/{id}:
+ *   delete:
+ *     summary: Achievement löschen
+ *     description: Löscht ein Achievement (deaktiviert es nur)
+ *     tags: [Admin, Achievements]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *           format: uuid
+ *         description: ID des Achievements
+ *     responses:
+ *       200:
+ *         description: Achievement erfolgreich deaktiviert
+ *       404:
+ *         description: Achievement nicht gefunden
+ *       500:
+ *         description: Server-Fehler
+ */
+// Delete (deactivate) achievement
+router.delete('/v1/admin/achievements/:id', requireAdminAuth, async (req, res) => {
+    try {
+        const { id } = req.params;
+
+        const result = await pool.query(`
+            UPDATE achievements SET is_active = false
+            WHERE id = $1
+            RETURNING *
+        `, [id]);
+
+        if (result.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Achievement nicht gefunden'
+            });
+        }
+
+        res.json({
+            success: true,
+            message: 'Achievement erfolgreich deaktiviert',
+            data: result.rows[0]
+        });
+    } catch (error) {
+        console.error('Error deactivating achievement:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Deaktivieren des Achievements'
+        });
+    }
+});
+
+/**
+ * @swagger
+ * /api/admin/achievements/players:
+ *   get:
+ *     summary: Alle Spieler mit ihren Achievements abrufen
+ *     description: Ruft alle Spieler mit ihren Achievement-Statistiken ab
+ *     tags: [Admin, Achievements]
+ *     responses:
+ *       200:
+ *         description: Liste aller Spieler mit Achievement-Statistiken
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 data:
+ *                   type: array
+ *                   items:
+ *                     type: object
+ *                     properties:
+ *                       id:
+ *                         type: string
+ *                         format: uuid
+ *                       firstname:
+ *                         type: string
+ *                       lastname:
+ *                         type: string
+ *                       total_achievements:
+ *                         type: integer
+ *                       completed_achievements:
+ *                         type: integer
+ *                       total_points:
+ *                         type: integer
+ *                       completion_percentage:
+ *                         type: number
+ *       500:
+ *         description: Server-Fehler
+ */
+// Get all players with achievement statistics
+router.get('/v1/admin/achievements/players', requireAdminAuth, async (req, res) => {
+    try {
+        const result = await pool.query(`
+            SELECT 
+                p.id,
+                p.firstname,
+                p.lastname,
+                COUNT(DISTINCT a.id) as total_achievements,
+                COUNT(DISTINCT CASE WHEN pa.is_completed = true THEN pa.achievement_id END) as completed_achievements,
+                COALESCE(SUM(CASE WHEN pa.is_completed = true THEN a.points ELSE 0 END), 0) as total_points,
+                CASE 
+                    WHEN COUNT(DISTINCT a.id) > 0 THEN 
+                        ROUND((COUNT(DISTINCT CASE WHEN pa.is_completed = true THEN pa.achievement_id END)::numeric / COUNT(DISTINCT a.id)) * 100, 2)
+                    ELSE 0 
+                END as completion_percentage
+            FROM players p
+            CROSS JOIN achievements a
+            LEFT JOIN player_achievements pa ON a.id = pa.achievement_id AND pa.player_id = p.id
+            WHERE a.is_active = true
+            GROUP BY p.id, p.firstname, p.lastname
+            ORDER BY total_points DESC, completion_percentage DESC, p.lastname, p.firstname
+        `);
+
+        res.json({
+            success: true,
+            data: result.rows
+        });
+    } catch (error) {
+        console.error('Error fetching players with achievements:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Spieler-Achievements'
+        });
+    }
+});
+
+/**
+ * @swagger
+ * /api/admin/achievements/players/{playerId}:
+ *   get:
+ *     summary: Achievements eines bestimmten Spielers abrufen
+ *     description: Ruft alle Achievements für einen bestimmten Spieler ab
+ *     tags: [Admin, Achievements]
+ *     parameters:
+ *       - in: path
+ *         name: playerId
+ *         required: true
+ *         schema:
+ *           type: string
+ *           format: uuid
+ *         description: ID des Spielers
+ *     responses:
+ *       200:
+ *         description: Achievements des Spielers
+ *       404:
+ *         description: Spieler nicht gefunden
+ *       500:
+ *         description: Server-Fehler
+ */
+// Get specific player achievements
+router.get('/v1/admin/achievements/players/:playerId', requireAdminAuth, async (req, res) => {
+    try {
+        const { playerId } = req.params;
+
+        // Check if player exists
+        const playerCheck = await pool.query('SELECT id, firstname, lastname FROM players WHERE id = $1', [playerId]);
+        if (playerCheck.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Spieler nicht gefunden'
+            });
+        }
+
+        const result = await pool.query(`
+            SELECT 
+                a.id,
+                a.name,
+                a.name_en,
+                a.description,
+                a.description_en,
+                a.category,
+                a.condition_type,
+                a.condition_value,
+                a.icon,
+                a.points,
+                a.is_active,
+                a.can_be_earned_multiple_times,
+                COALESCE(MAX(pa.progress), 0) as progress,
+                COALESCE(COUNT(pa.id) > 0, false) as is_completed,
+                MAX(pa.earned_at) as earned_at,
+                COUNT(pa.id) as completion_count
+            FROM achievements a
+            LEFT JOIN player_achievements pa ON a.id = pa.achievement_id AND pa.player_id = $1 AND pa.is_completed = true
+            WHERE a.is_active = true
+            GROUP BY a.id, a.name, a.name_en, a.description, a.description_en, a.category, 
+                     a.condition_type, a.condition_value, a.icon, a.points, a.is_active, a.can_be_earned_multiple_times
+            ORDER BY 
+                is_completed DESC,
+                a.category,
+                a.points DESC
+        `, [playerId]);
+
+        res.json({
+            success: true,
+            player: playerCheck.rows[0],
+            data: result.rows
+        });
+    } catch (error) {
+        console.error('Error fetching player achievements:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Laden der Spieler-Achievements'
+        });
+    }
+});
+
+/**
+ * @swagger
+ * /api/admin/achievements/players/{playerId}/award:
+ *   post:
+ *     summary: Achievement an Spieler vergeben
+ *     description: Vergibt ein Achievement manuell an einen Spieler
+ *     tags: [Admin, Achievements]
+ *     parameters:
+ *       - in: path
+ *         name: playerId
+ *         required: true
+ *         schema:
+ *           type: string
+ *           format: uuid
+ *         description: ID des Spielers
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - achievement_id
+ *             properties:
+ *               achievement_id:
+ *                 type: string
+ *                 format: uuid
+ *                 description: ID des Achievements
+ *               progress:
+ *                 type: integer
+ *                 description: Fortschritt des Achievements
+ *                 default: 1
+ *     responses:
+ *       201:
+ *         description: Achievement erfolgreich vergeben
+ *       400:
+ *         description: Ungültige Eingabedaten
+ *       404:
+ *         description: Spieler oder Achievement nicht gefunden
+ *       500:
+ *         description: Server-Fehler
+ */
+// Award achievement to player
+router.post('/v1/admin/achievements/players/:playerId/award', requireAdminAuth, async (req, res) => {
+    try {
+        const { playerId } = req.params;
+        const { achievement_id, progress = 1 } = req.body;
+
+        if (!achievement_id) {
+            return res.status(400).json({
+                success: false,
+                message: 'Achievement-ID ist erforderlich'
+            });
+        }
+
+        // Check if player exists
+        const playerCheck = await pool.query('SELECT id, firstname, lastname FROM players WHERE id = $1', [playerId]);
+        if (playerCheck.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Spieler nicht gefunden'
+            });
+        }
+
+        // Check if achievement exists
+        const achievementCheck = await pool.query('SELECT id, name FROM achievements WHERE id = $1', [achievement_id]);
+        if (achievementCheck.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Achievement nicht gefunden'
+            });
+        }
+
+        // Award the achievement
+        const result = await pool.query(`
+            INSERT INTO player_achievements (player_id, achievement_id, progress, is_completed, earned_at)
+            VALUES ($1, $2, $3, true, NOW())
+            RETURNING *
+        `, [playerId, achievement_id, progress]);
+
+        res.status(201).json({
+            success: true,
+            message: `Achievement "${achievementCheck.rows[0].name}" erfolgreich an ${playerCheck.rows[0].firstname} ${playerCheck.rows[0].lastname} vergeben`,
+            data: result.rows[0]
+        });
+    } catch (error) {
+        console.error('Error awarding achievement:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Vergeben des Achievements'
+        });
+    }
+});
+
+/**
+ * @swagger
+ * /api/admin/achievements/players/{playerId}/revoke:
+ *   delete:
+ *     summary: Achievement von Spieler entfernen
+ *     description: Entfernt ein Achievement von einem Spieler
+ *     tags: [Admin, Achievements]
+ *     parameters:
+ *       - in: path
+ *         name: playerId
+ *         required: true
+ *         schema:
+ *           type: string
+ *           format: uuid
+ *         description: ID des Spielers
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - achievement_id
+ *             properties:
+ *               achievement_id:
+ *                 type: string
+ *                 format: uuid
+ *                 description: ID des Achievements
+ *     responses:
+ *       200:
+ *         description: Achievement erfolgreich entfernt
+ *       404:
+ *         description: Spieler oder Achievement nicht gefunden
+ *       500:
+ *         description: Server-Fehler
+ */
+// Revoke achievement from player
+router.delete('/v1/admin/achievements/players/:playerId/revoke', requireAdminAuth, async (req, res) => {
+    try {
+        const { playerId } = req.params;
+        const { achievement_id } = req.body;
+
+        if (!achievement_id) {
+            return res.status(400).json({
+                success: false,
+                message: 'Achievement-ID ist erforderlich'
+            });
+        }
+
+        // Check if player exists
+        const playerCheck = await pool.query('SELECT id, firstname, lastname FROM players WHERE id = $1', [playerId]);
+        if (playerCheck.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Spieler nicht gefunden'
+            });
+        }
+
+        // Get achievement name for response
+        const achievementCheck = await pool.query('SELECT id, name FROM achievements WHERE id = $1', [achievement_id]);
+        if (achievementCheck.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Achievement nicht gefunden'
+            });
+        }
+
+        // Remove the achievement
+        const result = await pool.query(`
+            DELETE FROM player_achievements 
+            WHERE player_id = $1 AND achievement_id = $2
+            RETURNING *
+        `, [playerId, achievement_id]);
+
+        if (result.rows.length === 0) {
+            return res.status(404).json({
+                success: false,
+                message: 'Spieler hat dieses Achievement nicht'
+            });
+        }
+
+        res.json({
+            success: true,
+            message: `Achievement "${achievementCheck.rows[0].name}" erfolgreich von ${playerCheck.rows[0].firstname} ${playerCheck.rows[0].lastname} entfernt`,
+            data: result.rows[0]
+        });
+    } catch (error) {
+        console.error('Error revoking achievement:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Entfernen des Achievements'
+        });
+    }
+});
+
+// Health check endpoint for backend connectivity (matches Arduino backendOnline() function)
+router.get('/v1/private/health', requireApiKey, async (req, res) => {
+    try {
+        // Test database connection
+        const client = await pool.connect();
+
+        // Simple query to test database connectivity
+        await client.query('SELECT 1');
+        client.release();
+
+        // If we reach here, the database is accessible
+        res.status(200).json({
+            success: true,
+            message: 'Database server connection successful',
+            status: 'online',
+            timestamp: new Date().toISOString()
+        });
+
+    } catch (error) {
+        console.error('Database server connection failed:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Database server connection failed',
+            status: 'offline',
+            error: error.message,
+            timestamp: new Date().toISOString()
+        });
+    }
+});
+
+module.exports = { router, requireApiKey };
diff --git a/routes/public.js b/routes/public.js
new file mode 100644
index 0000000..8e0f29d
--- /dev/null
+++ b/routes/public.js
@@ -0,0 +1,176 @@
+// routes/public.js
+const express = require('express');
+const { Pool } = require('pg');
+const router = express.Router();
+
+// PostgreSQL Pool mit .env Konfiguration
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    database: process.env.DB_NAME,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    ssl: process.env.DB_SSL === 'true' ? { rejectUnauthorized: false } : false
+});
+
+// Fehlerbehandlung für Pool
+pool.on('error', (err) => {
+    console.error('PostgreSQL Pool Fehler:', err);
+});
+
+// Public endpoint für Standorte (keine Authentifizierung erforderlich)
+router.get('/locations', async (req, res) => {
+    try {
+        const result = await pool.query('SELECT * FROM "GetLocations"');
+        
+        res.json({
+            success: true,
+            data: result.rows
+        });
+        
+    } catch (error) {
+        console.error('Fehler beim Abrufen der getlocations:', error);
+        res.status(500).json({ 
+            success: false, 
+            message: 'Fehler beim Abrufen der Standorte' 
+        });
+    }
+});
+
+// Public route to get times for location with parameter
+router.get('/times', async (req, res) => {
+    const { location } = req.query;
+    
+    try {
+        // First, let's check if the view exists and has data
+        const viewCheck = await pool.query('SELECT COUNT(*) as count FROM "GetTimesWithPlayerAndLocation"');
+        
+        // Check what location names are available
+        const availableLocations = await pool.query('SELECT DISTINCT location_name FROM "GetTimesWithPlayerAndLocation"');
+        
+        // Now search for the specific location
+        const result = await pool.query('SELECT * FROM "GetTimesWithPlayerAndLocation" WHERE location_name = $1', [location]);
+        
+        res.json({
+            success: true,
+            data: result.rows,
+            debug: {
+                searchedFor: location,
+                totalRecords: viewCheck.rows[0].count,
+                availableLocations: availableLocations.rows.map(r => r.location_name),
+                foundRecords: result.rows.length
+            }
+        });
+        
+    } catch (error) {
+        console.error('❌ Fehler beim Abrufen der Zeiten:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der Zeiten',
+            error: error.message
+        });
+    }
+});
+
+// Public route to get all times with player and location details for leaderboard
+router.get('/times-with-details', async (req, res) => {
+    try {
+        const { location, period } = req.query;
+        
+        // Build WHERE clause for location filter
+        let locationFilter = '';
+        if (location && location !== 'all') {
+            locationFilter = `AND l.name ILIKE '%${location}%'`;
+        }
+        
+        // Build WHERE clause for date filter using PostgreSQL timezone functions
+        let dateFilter = '';
+        if (period === 'today') {
+            // Today in local timezone (UTC+2)
+            dateFilter = `AND DATE(t.created_at AT TIME ZONE 'UTC' AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE`;
+        } else if (period === 'week') {
+            // This week starting from Monday in local timezone
+            dateFilter = `AND DATE(t.created_at AT TIME ZONE 'UTC' AT TIME ZONE 'Europe/Berlin') >= DATE_TRUNC('week', CURRENT_DATE)`;
+        } else if (period === 'month') {
+            // This month starting from 1st in local timezone
+            dateFilter = `AND DATE(t.created_at AT TIME ZONE 'UTC' AT TIME ZONE 'Europe/Berlin') >= DATE_TRUNC('month', CURRENT_DATE)`;
+        }
+        
+        // Get all times with player and location details, ordered by time (fastest first)
+        // SECURITY: Only return data needed for leaderboard display
+        const result = await pool.query(`
+            SELECT 
+                EXTRACT(EPOCH FROM t.recorded_time) as recorded_time_seconds,
+                t.created_at,
+                json_build_object(
+                    'firstname', p.firstname,
+                    'lastname', p.lastname
+                ) as player,
+                json_build_object(
+                    'name', l.name
+                ) as location
+            FROM times t
+            LEFT JOIN players p ON t.player_id = p.id
+            LEFT JOIN locations l ON t.location_id = l.id
+            WHERE 1=1 ${locationFilter} ${dateFilter}
+            ORDER BY t.recorded_time ASC
+            LIMIT 50
+        `);
+        
+        // Convert seconds to minutes:seconds.milliseconds format
+        const formattedResults = result.rows.map(row => {
+            const totalSeconds = parseFloat(row.recorded_time_seconds);
+            const minutes = Math.floor(totalSeconds / 60);
+            const seconds = Math.floor(totalSeconds % 60);
+            const milliseconds = Math.floor((totalSeconds % 1) * 1000);
+            
+            return {
+                ...row,
+                recorded_time: {
+                    minutes: minutes,
+                    seconds: seconds,
+                    milliseconds: milliseconds
+                }
+            };
+        });
+        
+        res.json(formattedResults);
+        
+    } catch (error) {
+        console.error('❌ Fehler beim Abrufen der Zeiten mit Details:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der Zeiten mit Details',
+            error: error.message
+        });
+    }
+});
+
+// Public route to get all locations for filter dropdown
+router.get('/locations', async (req, res) => {
+    try {
+        const result = await pool.query(`
+            SELECT id, name, latitude, longitude
+            FROM locations
+            ORDER BY name ASC
+        `);
+        
+        res.json({
+            success: true,
+            data: result.rows
+        });
+        
+    } catch (error) {
+        console.error('❌ Fehler beim Abrufen der Standorte:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Fehler beim Abrufen der Standorte',
+            error: error.message
+        });
+    }
+});
+
+
+
+
+module.exports = router;
diff --git a/scripts/best_time_achievements.js b/scripts/best_time_achievements.js
new file mode 100644
index 0000000..8bcef1e
--- /dev/null
+++ b/scripts/best_time_achievements.js
@@ -0,0 +1,198 @@
+const { Pool } = require('pg');
+require('dotenv').config();
+
+const pool = new Pool({
+    host: process.env.DB_HOST || 'localhost',
+    port: process.env.DB_PORT || 5432,
+    database: process.env.DB_NAME || 'ninjacross',
+    user: process.env.DB_USER || '',
+    password: process.env.DB_PASSWORD || '',
+    ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false
+});
+
+async function runBestTimeAchievements() {
+    const client = await pool.connect();
+    
+    try {
+        console.log('🏆 Starting best-time achievement check at 19:00...');
+        
+        const currentHour = new Date().getHours();
+        const currentDay = new Date().getDay(); // 0 = Sunday
+        const currentDate = new Date();
+        const isLastDayOfMonth = new Date(currentDate.getFullYear(), currentDate.getMonth() + 1, 0).getDate() === currentDate.getDate();
+        
+        console.log(`Current time: ${currentHour}:00`);
+        console.log(`Is Sunday: ${currentDay === 0}`);
+        console.log(`Is last day of month: ${isLastDayOfMonth}`);
+        
+        // Get all players who have played
+        const playersResult = await client.query(`
+            SELECT DISTINCT p.id, p.firstname, p.lastname
+            FROM players p
+            INNER JOIN times t ON p.id = t.player_id
+        `);
+        
+        console.log(`Found ${playersResult.rows.length} players with times`);
+        
+        let dailyAwards = 0;
+        let weeklyAwards = 0;
+        let monthlyAwards = 0;
+        
+        // Check best-time achievements for each player
+        for (const player of playersResult.rows) {
+            console.log(`Checking best-time achievements for ${player.firstname} ${player.lastname}...`);
+            
+            // Run best-time achievement check function
+            await client.query('SELECT check_best_time_achievements_timed($1)', [player.id]);
+            
+            // Check if new daily achievement was earned today
+            const dailyResult = await client.query(`
+                SELECT COUNT(*) as count
+                FROM player_achievements pa
+                INNER JOIN achievements a ON pa.achievement_id = a.id
+                WHERE pa.player_id = $1 
+                AND a.category = 'best_time' 
+                AND a.condition_type = 'daily_best'
+                AND pa.is_completed = true
+                AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+            `, [player.id]);
+            
+            if (parseInt(dailyResult.rows[0].count) > 0) {
+                dailyAwards++;
+                console.log(`  🥇 Daily best achievement earned!`);
+            }
+            
+            // Check if new weekly achievement was earned (only on Sunday)
+            if (currentDay === 0) {
+                const weeklyResult = await client.query(`
+                    SELECT COUNT(*) as count
+                    FROM player_achievements pa
+                    INNER JOIN achievements a ON pa.achievement_id = a.id
+                    WHERE pa.player_id = $1 
+                    AND a.category = 'best_time' 
+                    AND a.condition_type = 'weekly_best'
+                    AND pa.is_completed = true
+                    AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+                `, [player.id]);
+                
+                if (parseInt(weeklyResult.rows[0].count) > 0) {
+                    weeklyAwards++;
+                    console.log(`  🏆 Weekly best achievement earned!`);
+                }
+            }
+            
+            // Check if new monthly achievement was earned (only on last day of month)
+            if (isLastDayOfMonth) {
+                const monthlyResult = await client.query(`
+                    SELECT COUNT(*) as count
+                    FROM player_achievements pa
+                    INNER JOIN achievements a ON pa.achievement_id = a.id
+                    WHERE pa.player_id = $1 
+                    AND a.category = 'best_time' 
+                    AND a.condition_type = 'monthly_best'
+                    AND pa.is_completed = true
+                    AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+                `, [player.id]);
+                
+                if (parseInt(monthlyResult.rows[0].count) > 0) {
+                    monthlyAwards++;
+                    console.log(`  👑 Monthly best achievement earned!`);
+                }
+            }
+        }
+        
+        console.log(`\n🎉 Best-time achievement check completed!`);
+        console.log(`Daily awards: ${dailyAwards}`);
+        console.log(`Weekly awards: ${weeklyAwards}`);
+        console.log(`Monthly awards: ${monthlyAwards}`);
+        
+        // Get current best times for today
+        const bestTimesResult = await client.query(`
+            SELECT 
+                'daily' as period,
+                p.firstname || ' ' || p.lastname as player_name,
+                MIN(t.recorded_time) as best_time
+            FROM times t
+            INNER JOIN players p ON t.player_id = p.id
+            WHERE DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+            GROUP BY p.id, p.firstname, p.lastname
+            ORDER BY MIN(t.recorded_time) ASC
+            LIMIT 1
+        `);
+        
+        if (bestTimesResult.rows.length > 0) {
+            const dailyBest = bestTimesResult.rows[0];
+            console.log(`\n🥇 Today's best time: ${dailyBest.player_name} - ${dailyBest.best_time}`);
+        }
+        
+        // Get current best times for this week (if Sunday)
+        if (currentDay === 0) {
+            const weekStart = new Date();
+            weekStart.setDate(weekStart.getDate() - weekStart.getDay());
+            
+            const weeklyBestResult = await client.query(`
+                SELECT 
+                    'weekly' as period,
+                    p.firstname || ' ' || p.lastname as player_name,
+                    MIN(t.recorded_time) as best_time
+                FROM times t
+                INNER JOIN players p ON t.player_id = p.id
+                WHERE DATE(t.created_at AT TIME ZONE 'Europe/Berlin') >= $1
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') <= CURRENT_DATE
+                GROUP BY p.id, p.firstname, p.lastname
+                ORDER BY MIN(t.recorded_time) ASC
+                LIMIT 1
+            `, [weekStart.toISOString().split('T')[0]]);
+            
+            if (weeklyBestResult.rows.length > 0) {
+                const weeklyBest = weeklyBestResult.rows[0];
+                console.log(`🏆 This week's best time: ${weeklyBest.player_name} - ${weeklyBest.best_time}`);
+            }
+        }
+        
+        // Get current best times for this month (if last day of month)
+        if (isLastDayOfMonth) {
+            const monthStart = new Date(currentDate.getFullYear(), currentDate.getMonth(), 1);
+            
+            const monthlyBestResult = await client.query(`
+                SELECT 
+                    'monthly' as period,
+                    p.firstname || ' ' || p.lastname as player_name,
+                    MIN(t.recorded_time) as best_time
+                FROM times t
+                INNER JOIN players p ON t.player_id = p.id
+                WHERE DATE(t.created_at AT TIME ZONE 'Europe/Berlin') >= $1
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') <= CURRENT_DATE
+                GROUP BY p.id, p.firstname, p.lastname
+                ORDER BY MIN(t.recorded_time) ASC
+                LIMIT 1
+            `, [monthStart.toISOString().split('T')[0]]);
+            
+            if (monthlyBestResult.rows.length > 0) {
+                const monthlyBest = monthlyBestResult.rows[0];
+                console.log(`👑 This month's best time: ${monthlyBest.player_name} - ${monthlyBest.best_time}`);
+            }
+        }
+        
+    } catch (error) {
+        console.error('❌ Error running best-time achievements:', error);
+        throw error;
+    } finally {
+        client.release();
+    }
+}
+
+// Run if called directly
+if (require.main === module) {
+    runBestTimeAchievements()
+        .then(() => {
+            console.log('✅ Best-time achievements script completed successfully');
+            process.exit(0);
+        })
+        .catch((error) => {
+            console.error('❌ Best-time achievements script failed:', error);
+            process.exit(1);
+        });
+}
+
+module.exports = { runBestTimeAchievements };
diff --git a/scripts/best_time_notifications.js b/scripts/best_time_notifications.js
new file mode 100644
index 0000000..daeb7a1
--- /dev/null
+++ b/scripts/best_time_notifications.js
@@ -0,0 +1,141 @@
+const { Pool } = require('pg');
+const cron = require('node-cron');
+
+// Database connection
+const pool = new Pool({
+    user: 'postgres',
+    host: 'localhost',
+    database: 'ninjacross',
+    password: 'postgres',
+    port: 5432,
+});
+
+async function checkAndNotifyBestTimes() {
+    try {
+        console.log('🔔 Checking best times for notifications...');
+        
+        const currentDate = new Date();
+        const today = currentDate.toISOString().split('T')[0];
+        const weekStart = new Date(currentDate.setDate(currentDate.getDate() - currentDate.getDay()));
+        const monthStart = new Date(currentDate.getFullYear(), currentDate.getMonth(), 1);
+        
+        // Check daily best times
+        const dailyBestQuery = `
+            WITH daily_best AS (
+                SELECT 
+                    t.player_id,
+                    MIN(t.recorded_time) as best_time,
+                    p.name as player_name,
+                    p.email
+                FROM times t
+                JOIN players p ON t.player_id = p.id
+                WHERE DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = $1
+                GROUP BY t.player_id, p.name, p.email
+            ),
+            global_daily_best AS (
+                SELECT MIN(best_time) as global_best
+                FROM daily_best
+            )
+            SELECT 
+                db.player_id,
+                db.player_name,
+                db.email,
+                db.best_time,
+                gdb.global_best
+            FROM daily_best db
+            CROSS JOIN global_daily_best gdb
+            WHERE db.best_time = gdb.global_best
+        `;
+        
+        const dailyResult = await pool.query(dailyBestQuery, [today]);
+        
+        for (const row of dailyResult.rows) {
+            console.log(`🏆 Daily best time: ${row.player_name} with ${row.best_time}`);
+            // Here we would send the notification
+            // For now, just log it
+        }
+        
+        // Check weekly best times
+        const weeklyBestQuery = `
+            WITH weekly_best AS (
+                SELECT 
+                    t.player_id,
+                    MIN(t.recorded_time) as best_time,
+                    p.name as player_name,
+                    p.email
+                FROM times t
+                JOIN players p ON t.player_id = p.id
+                WHERE DATE(t.created_at AT TIME ZONE 'Europe/Berlin') >= $1
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') <= $2
+                GROUP BY t.player_id, p.name, p.email
+            ),
+            global_weekly_best AS (
+                SELECT MIN(best_time) as global_best
+                FROM weekly_best
+            )
+            SELECT 
+                wb.player_id,
+                wb.player_name,
+                wb.email,
+                wb.best_time,
+                gwb.global_best
+            FROM weekly_best wb
+            CROSS JOIN global_weekly_best gwb
+            WHERE wb.best_time = gwb.global_best
+        `;
+        
+        const weeklyResult = await pool.query(weeklyBestQuery, [weekStart.toISOString().split('T')[0], today]);
+        
+        for (const row of weeklyResult.rows) {
+            console.log(`🏆 Weekly best time: ${row.player_name} with ${row.best_time}`);
+        }
+        
+        // Check monthly best times
+        const monthlyBestQuery = `
+            WITH monthly_best AS (
+                SELECT 
+                    t.player_id,
+                    MIN(t.recorded_time) as best_time,
+                    p.name as player_name,
+                    p.email
+                FROM times t
+                JOIN players p ON t.player_id = p.id
+                WHERE DATE(t.created_at AT TIME ZONE 'Europe/Berlin') >= $1
+                AND DATE(t.created_at AT TIME ZONE 'Europe/Berlin') <= $2
+                GROUP BY t.player_id, p.name, p.email
+            ),
+            global_monthly_best AS (
+                SELECT MIN(best_time) as global_best
+                FROM monthly_best
+            )
+            SELECT 
+                mb.player_id,
+                mb.player_name,
+                mb.email,
+                mb.best_time,
+                gmb.global_best
+            FROM monthly_best mb
+            CROSS JOIN global_monthly_best gmb
+            WHERE mb.best_time = gmb.global_best
+        `;
+        
+        const monthlyResult = await pool.query(monthlyBestQuery, [monthStart.toISOString().split('T')[0], today]);
+        
+        for (const row of monthlyResult.rows) {
+            console.log(`🏆 Monthly best time: ${row.player_name} with ${row.best_time}`);
+        }
+        
+        console.log('✅ Best time notifications check completed');
+        
+    } catch (error) {
+        console.error('❌ Error checking best times:', error);
+    }
+}
+
+// Schedule to run every day at 19:00 (7 PM)
+cron.schedule('0 19 * * *', () => {
+    console.log('🕐 Running best time notifications check...');
+    checkAndNotifyBestTimes();
+});
+
+console.log('📅 Best time notifications scheduler started - runs daily at 19:00');
diff --git a/scripts/create-user.js b/scripts/create-user.js
new file mode 100644
index 0000000..05756fd
--- /dev/null
+++ b/scripts/create-user.js
@@ -0,0 +1,109 @@
+// scripts/create-user.js
+const { Pool } = require('pg');
+const bcrypt = require('bcrypt');
+const readline = require('readline');
+require('dotenv').config();
+
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    database: process.env.DB_NAME,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    ssl: process.env.DB_SSL === 'true' ? { rejectUnauthorized: false } : false
+});
+
+// Readline Interface für Benutzereingaben
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+// Hilfsfunktion für Benutzereingaben
+function askQuestion(question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            resolve(answer.trim());
+        });
+    });
+}
+
+async function createUser() {
+    try {
+        console.log('👤 Erstelle neuen Benutzer...\n');
+        
+        // Verbindung testen
+        await pool.query('SELECT NOW()');
+        console.log('✅ Datenbankverbindung erfolgreich\n');
+        
+        // Benutzereingaben abfragen
+        const username = await askQuestion('Benutzername eingeben: ');
+        if (!username) {
+            console.log('❌ Benutzername darf nicht leer sein!');
+            return;
+        }
+        
+        const password = await askQuestion('Passwort eingeben: ');
+        if (!password) {
+            console.log('❌ Passwort darf nicht leer sein!');
+            return;
+        }
+        
+        const confirmPassword = await askQuestion('Passwort bestätigen: ');
+        if (password !== confirmPassword) {
+            console.log('❌ Passwörter stimmen nicht überein!');
+            return;
+        }
+        
+        console.log('\n🔄 Erstelle Benutzer...');
+        
+        // Prüfen ob Benutzer bereits existiert
+        const existingUser = await pool.query(
+            'SELECT id FROM adminusers WHERE username = $1',
+            [username]
+        );
+        
+        if (existingUser.rows.length > 0) {
+            console.log(`ℹ️ Benutzer "${username}" existiert bereits`);
+            
+            const update = await askQuestion('Passwort aktualisieren? (j/n): ');
+            if (update.toLowerCase() === 'j' || update.toLowerCase() === 'ja' || update.toLowerCase() === 'y' || update.toLowerCase() === 'yes') {
+                const passwordHash = await bcrypt.hash(password, 10);
+                await pool.query(
+                    'UPDATE adminusers SET password_hash = $1 WHERE username = $2',
+                    [passwordHash, username]
+                );
+                console.log(`✅ Passwort für Benutzer "${username}" aktualisiert`);
+            } else {
+                console.log('❌ Vorgang abgebrochen');
+                return;
+            }
+        } else {
+            // Neuen Benutzer erstellen
+            const passwordHash = await bcrypt.hash(password, 10);
+            await pool.query(
+                'INSERT INTO adminusers (username, password_hash) VALUES ($1, $2)',
+                [username, passwordHash]
+            );
+            console.log(`✅ Benutzer "${username}" erfolgreich erstellt`);
+        }
+        
+        console.log('\n📝 Anmeldedaten:');
+        console.log(`   Benutzername: ${username}`);
+        console.log(`   Passwort: ${password}`);
+        
+    } catch (error) {
+        console.error('❌ Fehler beim Erstellen des Benutzers:', error);
+        process.exit(1);
+    } finally {
+        rl.close();
+        await pool.end();
+    }
+}
+
+// Skript ausführen wenn direkt aufgerufen
+if (require.main === module) {
+    createUser();
+}
+
+module.exports = { createUser };
diff --git a/scripts/daily_achievements.js b/scripts/daily_achievements.js
new file mode 100644
index 0000000..55b2376
--- /dev/null
+++ b/scripts/daily_achievements.js
@@ -0,0 +1,110 @@
+const { Pool } = require('pg');
+require('dotenv').config();
+
+const pool = new Pool({
+    connectionString: process.env.DATABASE_URL,
+    ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false
+});
+
+async function runDailyAchievements() {
+    const client = await pool.connect();
+    
+    try {
+        console.log('🎯 Starting daily achievement check...');
+        
+        // Get all players who have played today
+        const playersResult = await client.query(`
+            SELECT DISTINCT p.id, p.firstname, p.lastname
+            FROM players p
+            INNER JOIN times t ON p.id = t.player_id
+            WHERE DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+        `);
+        
+        console.log(`Found ${playersResult.rows.length} players who played today`);
+        
+        let totalAchievements = 0;
+        
+        // Check achievements for each player
+        for (const player of playersResult.rows) {
+            console.log(`Checking achievements for ${player.firstname} ${player.lastname}...`);
+            
+            // Run achievement check function
+            await client.query('SELECT check_all_achievements($1)', [player.id]);
+            
+            // Count new achievements earned today
+            const newAchievementsResult = await client.query(`
+                SELECT COUNT(*) as count
+                FROM player_achievements pa
+                INNER JOIN achievements a ON pa.achievement_id = a.id
+                WHERE pa.player_id = $1 
+                AND pa.is_completed = true
+                AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+            `, [player.id]);
+            
+            const newAchievements = parseInt(newAchievementsResult.rows[0].count);
+            totalAchievements += newAchievements;
+            
+            if (newAchievements > 0) {
+                console.log(`  ✅ ${newAchievements} new achievements earned!`);
+                
+                // Get details of new achievements
+                const achievementsResult = await client.query(`
+                    SELECT a.name, a.description, a.icon, a.points
+                    FROM player_achievements pa
+                    INNER JOIN achievements a ON pa.achievement_id = a.id
+                    WHERE pa.player_id = $1 
+                    AND pa.is_completed = true
+                    AND DATE(pa.earned_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+                    ORDER BY pa.earned_at DESC
+                `, [player.id]);
+                
+                achievementsResult.rows.forEach(achievement => {
+                    console.log(`    ${achievement.icon} ${achievement.name} (+${achievement.points} points)`);
+                });
+            } else {
+                console.log(`  ℹ️  No new achievements`);
+            }
+        }
+        
+        console.log(`\n🎉 Daily achievement check completed!`);
+        console.log(`Total new achievements earned: ${totalAchievements}`);
+        
+        // Log summary statistics
+        const statsResult = await client.query(`
+            SELECT 
+                COUNT(DISTINCT pa.player_id) as players_with_achievements,
+                COUNT(pa.id) as total_achievements_earned,
+                SUM(a.points) as total_points_earned
+            FROM player_achievements pa
+            INNER JOIN achievements a ON pa.achievement_id = a.id
+            WHERE pa.is_completed = true
+        `);
+        
+        const stats = statsResult.rows[0];
+        console.log(`\n📊 Overall Statistics:`);
+        console.log(`Players with achievements: ${stats.players_with_achievements}`);
+        console.log(`Total achievements earned: ${stats.total_achievements_earned}`);
+        console.log(`Total points earned: ${stats.total_points_earned || 0}`);
+        
+    } catch (error) {
+        console.error('❌ Error running daily achievements:', error);
+        throw error;
+    } finally {
+        client.release();
+    }
+}
+
+// Run if called directly
+if (require.main === module) {
+    runDailyAchievements()
+        .then(() => {
+            console.log('✅ Daily achievements script completed successfully');
+            process.exit(0);
+        })
+        .catch((error) => {
+            console.error('❌ Daily achievements script failed:', error);
+            process.exit(1);
+        });
+}
+
+module.exports = { runDailyAchievements };
diff --git a/scripts/enhanced_player_notifications.js b/scripts/enhanced_player_notifications.js
new file mode 100644
index 0000000..81dcace
--- /dev/null
+++ b/scripts/enhanced_player_notifications.js
@@ -0,0 +1,285 @@
+const { Pool } = require('pg');
+const webpush = require('web-push');
+
+// Database connection
+const pool = new Pool({
+    user: process.env.DB_USER || 'postgres',
+    host: process.env.DB_HOST || 'localhost',
+    database: process.env.DB_NAME || 'ninjacross',
+    password: process.env.DB_PASSWORD || 'postgres',
+    port: process.env.DB_PORT || 5432,
+});
+
+// VAPID keys (same as push-service.js)
+const vapidKeys = {
+    publicKey: 'BJmNVx0C3XeVxeKGTP9c-Z4HcuZNmdk6QdiLocZgCmb-miCS0ESFO3W2TvJlRhhNAShV63pWA5p36BTVSetyTds',
+    privateKey: 'HBdRCtmZUAzsWpVjZ2LDaoWliIPHldAb5ExAt8bvDeg'
+};
+
+webpush.setVapidDetails(
+    'mailto:admin@ninjacross.com',
+    vapidKeys.publicKey,
+    vapidKeys.privateKey
+);
+
+/**
+ * Send push notification to a specific player
+ */
+async function sendPushToPlayer(playerId, title, message, data = {}) {
+    try {
+        console.log(`📱 Sending push to player ${playerId}: ${title}`);
+        
+        const result = await pool.query(`
+            SELECT endpoint, p256dh, auth 
+            FROM player_subscriptions 
+            WHERE player_id = $1
+        `, [playerId]);
+        
+        if (result.rows.length === 0) {
+            console.log(`❌ No subscription found for player ${playerId}`);
+            return { success: false, reason: 'No subscription' };
+        }
+        
+        // Send to all subscriptions for this player
+        const results = [];
+        for (const row of result.rows) {
+            const subscription = {
+                endpoint: row.endpoint,
+                keys: {
+                    p256dh: row.p256dh,
+                    auth: row.auth
+                }
+            };
+            
+            const payload = JSON.stringify({
+                title: title,
+                body: message,
+                icon: '/pictures/favicon.ico',
+                badge: '/pictures/favicon.ico',
+                data: {
+                    url: '/dashboard.html',
+                    timestamp: Date.now(),
+                    ...data
+                },
+                actions: [
+                    {
+                        action: 'view',
+                        title: 'Dashboard öffnen'
+                    }
+                ]
+            });
+            
+            try {
+                await webpush.sendNotification(subscription, payload);
+                results.push({ success: true });
+            } catch (error) {
+                console.error(`❌ Error sending to subscription:`, error);
+                results.push({ success: false, error: error.message });
+            }
+        }
+        
+        const successCount = results.filter(r => r.success).length;
+        console.log(`✅ Push notification sent to ${successCount}/${result.rows.length} subscriptions for player ${playerId}`);
+        
+        return { 
+            success: successCount > 0, 
+            sent: successCount, 
+            total: result.rows.length 
+        };
+        
+    } catch (error) {
+        console.error(`❌ Error sending push to player ${playerId}:`, error);
+        return { success: false, error: error.message };
+    }
+}
+
+/**
+ * Send achievement notification to player
+ */
+async function sendAchievementNotification(playerId, achievement) {
+    const title = `🏆 ${achievement.name}`;
+    const message = achievement.description;
+    
+    return await sendPushToPlayer(playerId, title, message, {
+        type: 'achievement',
+        achievementId: achievement.id,
+        points: achievement.points
+    });
+}
+
+/**
+ * Send best time notification to player
+ */
+async function sendBestTimeNotification(playerId, timeType, locationName, time) {
+    const title = `🏁 ${timeType} Bestzeit!`;
+    const message = `Du hast die beste Zeit in ${locationName} mit ${time} erreicht!`;
+    
+    return await sendPushToPlayer(playerId, title, message, {
+        type: 'best_time',
+        timeType: timeType,
+        location: locationName,
+        time: time
+    });
+}
+
+/**
+ * Send daily summary notification to player
+ */
+async function sendDailySummaryNotification(playerId, summary) {
+    const title = `📊 Dein Tagesrückblick`;
+    const message = `Du hattest ${summary.runs} Läufe heute. Beste Zeit: ${summary.bestTime}`;
+    
+    return await sendPushToPlayer(playerId, title, message, {
+        type: 'daily_summary',
+        runs: summary.runs,
+        bestTime: summary.bestTime
+    });
+}
+
+/**
+ * Send weekly summary notification to player
+ */
+async function sendWeeklySummaryNotification(playerId, summary) {
+    const title = `📈 Deine Wochenzusammenfassung`;
+    const message = `Diese Woche: ${summary.runs} Läufe, ${summary.improvement}% Verbesserung!`;
+    
+    return await sendPushToPlayer(playerId, title, message, {
+        type: 'weekly_summary',
+        runs: summary.runs,
+        improvement: summary.improvement
+    });
+}
+
+/**
+ * Send notification to all logged in players
+ */
+async function sendNotificationToAllPlayers(title, message, data = {}) {
+    try {
+        console.log(`📢 Sending notification to all players: ${title}`);
+        
+        const result = await pool.query(`
+            SELECT ps.player_id, ps.endpoint, ps.p256dh, ps.auth, p.firstname, p.lastname
+            FROM player_subscriptions ps
+            JOIN players p ON ps.player_id = p.id
+            WHERE ps.player_id IS NOT NULL
+        `);
+        
+        if (result.rows.length === 0) {
+            console.log('❌ No player subscriptions found');
+            return { success: false, reason: 'No subscriptions' };
+        }
+        
+        const promises = result.rows.map(async (row) => {
+            const subscription = {
+                endpoint: row.endpoint,
+                keys: {
+                    p256dh: row.p256dh,
+                    auth: row.auth
+                }
+            };
+            
+            const payload = JSON.stringify({
+                title: title,
+                body: message,
+                icon: '/pictures/favicon.ico',
+                badge: '/pictures/favicon.ico',
+                data: {
+                    url: '/dashboard.html',
+                    timestamp: Date.now(),
+                    ...data
+                }
+            });
+            
+            try {
+                await webpush.sendNotification(subscription, payload);
+                return { 
+                    playerId: row.player_id, 
+                    playerName: `${row.firstname} ${row.lastname}`,
+                    success: true 
+                };
+            } catch (error) {
+                console.error(`❌ Error sending to player ${row.player_id}:`, error);
+                return { 
+                    playerId: row.player_id, 
+                    playerName: `${row.firstname} ${row.lastname}`,
+                    success: false, 
+                    error: error.message 
+                };
+            }
+        });
+        
+        const results = await Promise.all(promises);
+        const successCount = results.filter(r => r.success).length;
+        
+        console.log(`✅ Sent notifications to ${successCount}/${results.length} players`);
+        
+        return { 
+            success: true, 
+            sent: successCount, 
+            total: results.length,
+            results: results
+        };
+        
+    } catch (error) {
+        console.error('❌ Error sending notifications to all players:', error);
+        return { success: false, error: error.message };
+    }
+}
+
+/**
+ * Get player statistics for notifications
+ */
+async function getPlayerStats(playerId) {
+    try {
+        const result = await pool.query(`
+            SELECT 
+                p.firstname,
+                p.lastname,
+                COUNT(t.id) as total_runs,
+                MIN(t.recorded_time) as best_time,
+                COUNT(DISTINCT t.location_id) as locations_visited
+            FROM players p
+            LEFT JOIN times t ON p.id = t.player_id
+            WHERE p.id = $1
+            GROUP BY p.id, p.firstname, p.lastname
+        `, [playerId]);
+        
+        if (result.rows.length === 0) {
+            return null;
+        }
+        
+        return result.rows[0];
+    } catch (error) {
+        console.error('Error getting player stats:', error);
+        return null;
+    }
+}
+
+/**
+ * Check if player has push notifications enabled
+ */
+async function isPlayerPushEnabled(playerId) {
+    try {
+        const result = await pool.query(`
+            SELECT COUNT(*) as count 
+            FROM player_subscriptions 
+            WHERE player_id = $1
+        `, [playerId]);
+        
+        return result.rows[0].count > 0;
+    } catch (error) {
+        console.error('Error checking push status:', error);
+        return false;
+    }
+}
+
+module.exports = {
+    sendPushToPlayer,
+    sendAchievementNotification,
+    sendBestTimeNotification,
+    sendDailySummaryNotification,
+    sendWeeklySummaryNotification,
+    sendNotificationToAllPlayers,
+    getPlayerStats,
+    isPlayerPushEnabled
+};
diff --git a/scripts/fix_player_subscriptions.js b/scripts/fix_player_subscriptions.js
new file mode 100644
index 0000000..51b9968
--- /dev/null
+++ b/scripts/fix_player_subscriptions.js
@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+/**
+ * Fix Player Subscriptions Script
+ * 
+ * This script fixes the player_subscriptions table by:
+ * 1. Identifying orphaned subscriptions (UUIDs that don't match any player)
+ * 2. Optionally migrating them to real player IDs
+ * 3. Cleaning up invalid subscriptions
+ */
+
+const { Pool } = require('pg');
+
+// Database connection
+const pool = new Pool({
+    user: process.env.DB_USER || 'postgres',
+    host: process.env.DB_HOST || 'localhost',
+    database: process.env.DB_NAME || 'ninjacross',
+    password: process.env.DB_PASSWORD || 'postgres',
+    port: process.env.DB_PORT || 5432,
+});
+
+async function fixPlayerSubscriptions() {
+    console.log('🔧 Starting Player Subscriptions Fix...\n');
+    
+    try {
+        // 1. Find orphaned subscriptions (UUIDs that don't match any player)
+        console.log('📊 Step 1: Finding orphaned subscriptions...');
+        const orphanedQuery = `
+            SELECT ps.player_id, ps.created_at, ps.endpoint
+            FROM player_subscriptions ps
+            LEFT JOIN players p ON ps.player_id = p.id
+            WHERE p.id IS NULL
+        `;
+        
+        const orphanedResult = await pool.query(orphanedQuery);
+        console.log(`Found ${orphanedResult.rows.length} orphaned subscriptions`);
+        
+        if (orphanedResult.rows.length > 0) {
+            console.log('\n📋 Orphaned subscriptions:');
+            orphanedResult.rows.forEach((sub, index) => {
+                console.log(`  ${index + 1}. Player ID: ${sub.player_id}`);
+                console.log(`     Created: ${sub.created_at}`);
+                console.log(`     Endpoint: ${sub.endpoint.substring(0, 50)}...`);
+            });
+        }
+        
+        // 2. Find players without subscriptions
+        console.log('\n📊 Step 2: Finding players without subscriptions...');
+        const playersWithoutSubsQuery = `
+            SELECT p.id, p.firstname, p.lastname, p.supabase_user_id
+            FROM players p
+            LEFT JOIN player_subscriptions ps ON p.id = ps.player_id
+            WHERE ps.player_id IS NULL
+        `;
+        
+        const playersWithoutSubsResult = await pool.query(playersWithoutSubsQuery);
+        console.log(`Found ${playersWithoutSubsResult.rows.length} players without subscriptions`);
+        
+        if (playersWithoutSubsResult.rows.length > 0) {
+            console.log('\n📋 Players without subscriptions:');
+            playersWithoutSubsResult.rows.forEach((player, index) => {
+                console.log(`  ${index + 1}. ${player.firstname} ${player.lastname} (${player.id})`);
+                console.log(`     Supabase User ID: ${player.supabase_user_id || 'None'}`);
+            });
+        }
+        
+        // 3. Show current subscription statistics
+        console.log('\n📊 Step 3: Current subscription statistics...');
+        const statsQuery = `
+            SELECT 
+                COUNT(*) as total_subscriptions,
+                COUNT(DISTINCT ps.player_id) as unique_player_ids,
+                COUNT(p.id) as linked_to_players,
+                COUNT(*) - COUNT(p.id) as orphaned_count
+            FROM player_subscriptions ps
+            LEFT JOIN players p ON ps.player_id = p.id
+        `;
+        
+        const statsResult = await pool.query(statsQuery);
+        const stats = statsResult.rows[0];
+        
+        console.log(`Total subscriptions: ${stats.total_subscriptions}`);
+        console.log(`Unique player IDs: ${stats.unique_player_ids}`);
+        console.log(`Linked to real players: ${stats.linked_to_players}`);
+        console.log(`Orphaned subscriptions: ${stats.orphaned_count}`);
+        
+        // 4. Ask user what to do
+        console.log('\n🔧 Step 4: What would you like to do?');
+        console.log('1. Clean up orphaned subscriptions (DELETE)');
+        console.log('2. Keep orphaned subscriptions (no action)');
+        console.log('3. Show detailed analysis only');
+        
+        // For now, just show the analysis
+        console.log('\n✅ Analysis complete. No changes made.');
+        console.log('\n💡 Recommendations:');
+        console.log('- Orphaned subscriptions should be cleaned up');
+        console.log('- New subscriptions will now use real player IDs');
+        console.log('- Existing valid subscriptions will continue to work');
+        
+    } catch (error) {
+        console.error('❌ Error fixing player subscriptions:', error);
+    } finally {
+        await pool.end();
+    }
+}
+
+// Clean up orphaned subscriptions
+async function cleanupOrphanedSubscriptions() {
+    console.log('🧹 Cleaning up orphaned subscriptions...');
+    
+    try {
+        const deleteQuery = `
+            DELETE FROM player_subscriptions 
+            WHERE player_id NOT IN (SELECT id FROM players)
+        `;
+        
+        const result = await pool.query(deleteQuery);
+        console.log(`✅ Deleted ${result.rowCount} orphaned subscriptions`);
+        
+    } catch (error) {
+        console.error('❌ Error cleaning up subscriptions:', error);
+    }
+}
+
+// Run the script
+if (require.main === module) {
+    fixPlayerSubscriptions();
+}
+
+module.exports = {
+    fixPlayerSubscriptions,
+    cleanupOrphanedSubscriptions
+};
diff --git a/scripts/init-db.js b/scripts/init-db.js
new file mode 100644
index 0000000..2f4e021
--- /dev/null
+++ b/scripts/init-db.js
@@ -0,0 +1,107 @@
+// scripts/init-db.js
+const { Pool } = require('pg');
+const bcrypt = require('bcrypt');
+require('dotenv').config();
+
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    database: process.env.DB_NAME,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    ssl: process.env.DB_SSL === 'true' ? { rejectUnauthorized: false } : false
+});
+
+async function initDatabase() {
+    try {
+        console.log('🚀 Initialisiere Datenbank...');
+        
+        // Verbindung testen
+        await pool.query('SELECT NOW()');
+        console.log('✅ Datenbankverbindung erfolgreich');
+        
+        // Adminusers Tabelle erstellen
+        await pool.query(`
+            CREATE TABLE IF NOT EXISTS adminusers (
+                id SERIAL PRIMARY KEY,
+                username VARCHAR(50) UNIQUE NOT NULL,
+                password_hash VARCHAR(255) NOT NULL,
+                is_active BOOLEAN DEFAULT true,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                last_login TIMESTAMP
+            )
+        `);
+        console.log('✅ adminusers Tabelle erstellt/überprüft');
+        
+        // API Tokens Tabelle erstellen
+        await pool.query(`
+            CREATE TABLE IF NOT EXISTS api_tokens (
+                id SERIAL PRIMARY KEY,
+                token VARCHAR(255) UNIQUE NOT NULL,
+                description TEXT,
+                standorte TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                expires_at TIMESTAMP,
+                is_active BOOLEAN DEFAULT true
+            )
+        `);
+        console.log('✅ api_tokens Tabelle erstellt/überprüft');
+        
+        // Locations Tabelle erstellen
+        await pool.query(`
+            CREATE TABLE IF NOT EXISTS locations (
+                id SERIAL PRIMARY KEY,
+                name VARCHAR(255) UNIQUE NOT NULL,
+                latitude DECIMAL(10, 8) NOT NULL,
+                longitude DECIMAL(11, 8) NOT NULL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        console.log('✅ locations Tabelle erstellt/überprüft');
+        
+        // Standardbenutzer erstellen (falls nicht vorhanden)
+        const existingUser = await pool.query(
+            'SELECT id FROM adminusers WHERE username = $1',
+            ['admin']
+        );
+        
+        if (existingUser.rows.length === 0) {
+            const passwordHash = await bcrypt.hash('admin123', 10);
+            await pool.query(
+                'INSERT INTO adminusers (username, password_hash) VALUES ($1, $2)',
+                ['admin', passwordHash]
+            );
+            console.log('✅ Standardbenutzer "admin" mit Passwort "admin123" erstellt');
+        } else {
+            console.log('ℹ️ Standardbenutzer "admin" existiert bereits');
+        }
+        
+        // Index für bessere Performance
+        await pool.query(`
+            CREATE INDEX IF NOT EXISTS idx_adminusers_username ON adminusers(username);
+            CREATE INDEX IF NOT EXISTS idx_adminusers_active ON adminusers(is_active);
+            CREATE INDEX IF NOT EXISTS idx_api_tokens_token ON api_tokens(token);
+            CREATE INDEX IF NOT EXISTS idx_api_tokens_active ON api_tokens(is_active);
+            CREATE INDEX IF NOT EXISTS idx_locations_name ON locations(name);
+            CREATE INDEX IF NOT EXISTS idx_locations_coords ON locations(latitude, longitude);
+        `);
+        console.log('✅ Indizes erstellt/überprüft');
+        
+        console.log('🎉 Datenbank erfolgreich initialisiert!');
+        console.log('📝 Standardanmeldung: admin / admin123');
+        console.log('⚠️ Ändern Sie das Standardpasswort in der Produktion!');
+        
+    } catch (error) {
+        console.error('❌ Fehler bei der Datenbankinitialisierung:', error);
+        process.exit(1);
+    } finally {
+        await pool.end();
+    }
+}
+
+// Skript ausführen wenn direkt aufgerufen
+if (require.main === module) {
+    initDatabase();
+}
+
+module.exports = { initDatabase };
diff --git a/scripts/iphone_notifications.js b/scripts/iphone_notifications.js
new file mode 100644
index 0000000..55a7fb6
--- /dev/null
+++ b/scripts/iphone_notifications.js
@@ -0,0 +1,129 @@
+const { Pool } = require('pg');
+const webpush = require('web-push');
+
+// Database connection
+const pool = new Pool({
+    user: 'postgres',
+    host: 'localhost',
+    database: 'ninjacross',
+    password: 'postgres',
+    port: 5432,
+});
+
+// VAPID Keys (generate with: webpush.generateVAPIDKeys())
+const vapidKeys = {
+    publicKey: 'BEl62iUYgUivxIkv69yViEuiBIa40HI6F2B5L4h7Q8Y',
+    privateKey: 'your-private-key-here'
+};
+
+webpush.setVapidDetails(
+    'mailto:admin@ninjacross.es',
+    vapidKeys.publicKey,
+    vapidKeys.privateKey
+);
+
+// Store subscription endpoint for each player
+async function storePlayerSubscription(playerId, subscription) {
+    try {
+        await pool.query(`
+            INSERT INTO player_subscriptions (player_id, endpoint, p256dh, auth)
+            VALUES ($1, $2, $3, $4)
+        `, [
+            playerId,
+            subscription.endpoint,
+            subscription.keys.p256dh,
+            subscription.keys.auth
+        ]);
+        console.log(`✅ Subscription stored for player ${playerId}`);
+    } catch (error) {
+        console.error('Error storing subscription:', error);
+    }
+}
+
+// Send push notification to player
+async function sendPushNotification(playerId, title, message, icon = '🏆') {
+    try {
+        const result = await pool.query(`
+            SELECT endpoint, p256dh, auth 
+            FROM player_subscriptions 
+            WHERE player_id = $1
+        `, [playerId]);
+        
+        if (result.rows.length === 0) {
+            console.log(`No subscription found for player ${playerId}`);
+            return;
+        }
+        
+        const subscription = {
+            endpoint: result.rows[0].endpoint,
+            keys: {
+                p256dh: result.rows[0].p256dh,
+                auth: result.rows[0].auth
+            }
+        };
+        
+        const payload = JSON.stringify({
+            title: title,
+            body: message,
+            icon: '/pictures/favicon.ico',
+            badge: '/pictures/favicon.ico',
+            data: {
+                url: '/dashboard.html'
+            }
+        });
+        
+        await webpush.sendNotification(subscription, payload);
+        console.log(`✅ Push notification sent to player ${playerId}`);
+        
+    } catch (error) {
+        console.error('Error sending push notification:', error);
+    }
+}
+
+// Send best time notifications
+async function sendBestTimeNotifications() {
+    try {
+        console.log('🔔 Sending best time notifications...');
+        
+        // Get daily best
+        const dailyResult = await pool.query(`
+            WITH daily_best AS (
+                SELECT 
+                    t.player_id,
+                    MIN(t.recorded_time) as best_time,
+                    CONCAT(p.firstname, ' ', p.lastname) as player_name
+                FROM times t
+                JOIN players p ON t.player_id = p.id
+                WHERE DATE(t.created_at AT TIME ZONE 'Europe/Berlin') = CURRENT_DATE
+                GROUP BY t.player_id, p.firstname, p.lastname
+            )
+            SELECT 
+                player_id,
+                player_name,
+                best_time
+            FROM daily_best
+            WHERE best_time = (SELECT MIN(best_time) FROM daily_best)
+            LIMIT 1
+        `);
+        
+        if (dailyResult.rows.length > 0) {
+            const daily = dailyResult.rows[0];
+            await sendPushNotification(
+                daily.player_id,
+                '🏆 Tageskönig!',
+                `Glückwunsch ${daily.player_name}! Du hast die beste Zeit des Tages mit ${daily.best_time} erreicht!`
+            );
+        }
+        
+        console.log('✅ Best time notifications sent');
+        
+    } catch (error) {
+        console.error('❌ Error sending best time notifications:', error);
+    }
+}
+
+module.exports = {
+    storePlayerSubscription,
+    sendPushNotification,
+    sendBestTimeNotifications
+};
diff --git a/scripts/setup-players.js b/scripts/setup-players.js
new file mode 100644
index 0000000..6b53dc4
--- /dev/null
+++ b/scripts/setup-players.js
@@ -0,0 +1,87 @@
+// scripts/setup-players.js
+// Script to set up players table and fix the player name issue
+const { Pool } = require('pg');
+require('dotenv').config();
+
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    database: process.env.DB_NAME,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    ssl: process.env.DB_SSL === 'true' ? { rejectUnauthorized: false } : false
+});
+
+async function setupPlayers() {
+    try {
+        console.log('🚀 Setting up players table and views...');
+        
+        // Test connection
+        await pool.query('SELECT NOW()');
+        console.log('✅ Database connection successful');
+        
+        // Check if players table exists and has the expected structure
+        const tableCheck = await pool.query(`
+            SELECT column_name, data_type 
+            FROM information_schema.columns 
+            WHERE table_name = 'players'
+        `);
+        
+        if (tableCheck.rows.length === 0) {
+            console.log('❌ Players table not found. Please create it first with the structure:');
+            console.log('   - id (UUID)');
+            console.log('   - firstname (VARCHAR)');
+            console.log('   - lastname (VARCHAR)');
+            console.log('   - birthdate (DATE)');
+            console.log('   - created_at (TIMESTAMP)');
+            console.log('   - rfiduid (VARCHAR)');
+            process.exit(1);
+        }
+        
+        console.log('✅ Players table structure verified');
+        console.log('📋 Available columns:', tableCheck.rows.map(r => r.column_name).join(', '));
+        
+        // Create the updated view using your actual table structure
+        await pool.query(`
+            CREATE OR REPLACE VIEW "GetTimesWithPlayerAndLocation" AS
+            SELECT 
+                gt.*,
+                l.name as location_name,
+                l.latitude,
+                l.longitude,
+                COALESCE(CONCAT(p.firstname, ' ', p.lastname), 'Unknown Player') as player_name
+            FROM "gettimes" gt
+            JOIN locations l ON gt.location_id = l.id
+            LEFT JOIN players p ON gt.player_id = p.id
+        `);
+        console.log('✅ Updated view created');
+        
+        // Test the view
+        const testResult = await pool.query('SELECT COUNT(*) as count FROM "GetTimesWithPlayerAndLocation"');
+        console.log(`✅ View test successful: ${testResult.rows[0].count} records found`);
+        
+        // Show sample data
+        const sampleData = await pool.query('SELECT player_name, location_name, recorded_time FROM "GetTimesWithPlayerAndLocation" LIMIT 3');
+        console.log('📊 Sample data from view:');
+        sampleData.rows.forEach((row, index) => {
+            console.log(`  ${index + 1}. ${row.player_name} at ${row.location_name}: ${row.recorded_time}`);
+        });
+        
+        console.log('\n🎉 Setup completed successfully!');
+        console.log('📝 Your index.html should now display player names instead of IDs');
+        console.log('🔄 Restart your server to use the new view');
+        
+    } catch (error) {
+        console.error('❌ Error during setup:', error);
+        process.exit(1);
+    } finally {
+        await pool.end();
+    }
+}
+
+// Run if called directly
+if (require.main === module) {
+    setupPlayers();
+}
+
+module.exports = { setupPlayers };
diff --git a/scripts/setup_cron.js b/scripts/setup_cron.js
new file mode 100644
index 0000000..3f23e78
--- /dev/null
+++ b/scripts/setup_cron.js
@@ -0,0 +1,108 @@
+const { exec } = require('child_process');
+const path = require('path');
+
+// Cron job setup for achievements
+const cronJobs = [
+    {
+        name: 'daily_achievements',
+        // Run daily at 19:00 for best-time achievements
+        schedule: '0 19 * * *',
+        command: `cd ${__dirname} && node best_time_achievements.js >> /var/log/ninjaserver_achievements.log 2>&1`,
+        description: 'Daily best-time achievement check at 19:00'
+    },
+    {
+        name: 'weekly_achievements', 
+        // Run every Sunday at 19:00 for weekly best-time achievements
+        schedule: '0 19 * * 0',
+        command: `cd ${__dirname} && node best_time_achievements.js >> /var/log/ninjaserver_achievements.log 2>&1`,
+        description: 'Weekly best-time achievement check on Sunday at 19:00'
+    },
+    {
+        name: 'monthly_achievements',
+        // Run on last day of month at 19:00 for monthly best-time achievements
+        schedule: '0 19 28-31 * * [ $(date -d tomorrow +\\%d) -eq 1 ]',
+        command: `cd ${__dirname} && node best_time_achievements.js >> /var/log/ninjaserver_achievements.log 2>&1`,
+        description: 'Monthly best-time achievement check on last day of month at 19:00'
+    }
+];
+
+function setupCronJobs() {
+    console.log('🕐 Setting up best-time achievement cron jobs...');
+    
+    let cronEntries = [];
+    
+    // Create cron job entries
+    cronJobs.forEach(job => {
+        const cronEntry = `${job.schedule} ${job.command}`;
+        cronEntries.push(cronEntry);
+        console.log(`📅 ${job.name}: ${job.schedule} - ${job.description}`);
+    });
+    
+    // Add all cron jobs to crontab
+    const allCronEntries = cronEntries.join('\n');
+    exec(`(crontab -l 2>/dev/null; echo "${allCronEntries}") | crontab -`, (error, stdout, stderr) => {
+        if (error) {
+            console.error('❌ Error setting up cron jobs:', error);
+            return;
+        }
+        
+        if (stderr) {
+            console.error('⚠️  Cron job warning:', stderr);
+        }
+        
+        console.log('✅ All cron jobs setup successfully!');
+        console.log('📝 Logs will be written to: /var/log/ninjaserver_achievements.log');
+        
+        // Show current crontab
+        exec('crontab -l', (error, stdout, stderr) => {
+            if (!error) {
+                console.log('\n📋 Current crontab:');
+                console.log(stdout);
+            }
+        });
+    });
+}
+
+function removeCronJobs() {
+    console.log('🗑️  Removing best-time achievement cron jobs...');
+    
+    exec('crontab -l | grep -v "best_time_achievements.js" | crontab -', (error, stdout, stderr) => {
+        if (error) {
+            console.error('❌ Error removing cron jobs:', error);
+            return;
+        }
+        
+        console.log('✅ All cron jobs removed successfully!');
+    });
+}
+
+// Command line interface
+if (require.main === module) {
+    const command = process.argv[2];
+    
+    switch (command) {
+        case 'setup':
+            setupCronJobs();
+            break;
+        case 'remove':
+            removeCronJobs();
+            break;
+        case 'status':
+            exec('crontab -l | grep best_time_achievements', (error, stdout, stderr) => {
+                if (stdout) {
+                    console.log('✅ Best-time achievement cron jobs are active:');
+                    console.log(stdout);
+                } else {
+                    console.log('❌ No best-time achievement cron jobs found');
+                }
+            });
+            break;
+        default:
+            console.log('Usage: node setup_cron.js [setup|remove|status]');
+            console.log('  setup   - Add best-time achievement cron jobs (daily 19:00, Sunday 19:00, last day of month 19:00)');
+            console.log('  remove  - Remove all best-time achievement cron jobs');
+            console.log('  status  - Check if best-time achievement cron jobs are active');
+    }
+}
+
+module.exports = { setupCronJobs, removeCronJobs };
diff --git a/scripts/simulate-new-time.js b/scripts/simulate-new-time.js
new file mode 100644
index 0000000..8944e26
--- /dev/null
+++ b/scripts/simulate-new-time.js
@@ -0,0 +1,94 @@
+/**
+ * Simuliert das Aufzeichnen einer neuen Zeit und testet sofortige Achievements
+ * 
+ * Dieses Script simuliert, was passiert, wenn ein Spieler eine neue Zeit aufzeichnet
+ */
+
+const { Pool } = require('pg');
+const AchievementSystem = require('../lib/achievementSystem');
+require('dotenv').config();
+
+// Database connection
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    database: process.env.DB_NAME,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    ssl: process.env.DB_SSL === 'true' ? { rejectUnauthorized: false } : false
+});
+
+async function simulateNewTime() {
+    console.log('🎮 Simuliere neue Zeit-Aufzeichnung...\n');
+    
+    try {
+        // Hole einen Test-Spieler
+        const playerResult = await pool.query(`
+            SELECT p.id, p.firstname, p.lastname, p.rfiduid
+            FROM players p 
+            WHERE p.rfiduid IS NOT NULL 
+            LIMIT 1
+        `);
+        
+        if (playerResult.rows.length === 0) {
+            console.log('❌ Kein Spieler mit RFID gefunden');
+            return;
+        }
+        
+        const player = playerResult.rows[0];
+        console.log(`👤 Teste mit Spieler: ${player.firstname} ${player.lastname} (${player.rfiduid})`);
+        
+        // Hole eine Test-Location
+        const locationResult = await pool.query(`
+            SELECT id, name FROM locations LIMIT 1
+        `);
+        
+        if (locationResult.rows.length === 0) {
+            console.log('❌ Keine Location gefunden');
+            return;
+        }
+        
+        const location = locationResult.rows[0];
+        console.log(`📍 Teste mit Location: ${location.name}`);
+        
+        // Simuliere eine neue Zeit (etwas langsamer als die beste Zeit)
+        const testTime = '00:01:30.500'; // 1:30.500
+        console.log(`⏱️  Simuliere Zeit: ${testTime}`);
+        
+        // Füge die Zeit zur Datenbank hinzu
+        const timeResult = await pool.query(
+            `INSERT INTO times (player_id, location_id, recorded_time, created_at) 
+             VALUES ($1, $2, $3, $4) 
+             RETURNING id, player_id, created_at`,
+            [player.id, location.id, testTime, new Date()]
+        );
+        
+        console.log(`✅ Zeit erfolgreich gespeichert (ID: ${timeResult.rows[0].id})`);
+        
+        // Teste sofortige Achievements
+        console.log('\n🏆 Prüfe sofortige Achievements...');
+        const achievementSystem = new AchievementSystem();
+        await achievementSystem.loadAchievements();
+        
+        const newAchievements = await achievementSystem.checkImmediateAchievements(player.id);
+        
+        if (newAchievements.length > 0) {
+            console.log(`\n🎉 ${newAchievements.length} neue Achievements vergeben:`);
+            newAchievements.forEach(achievement => {
+                console.log(`   ${achievement.icon} ${achievement.name} (+${achievement.points} Punkte)`);
+            });
+        } else {
+            console.log('\nℹ️  Keine neuen Achievements vergeben');
+        }
+        
+        console.log('\n✅ Simulation erfolgreich abgeschlossen!');
+        
+    } catch (error) {
+        console.error('❌ Simulation fehlgeschlagen:', error);
+    } finally {
+        await pool.end();
+    }
+}
+
+// Führe Simulation aus
+simulateNewTime();
diff --git a/scripts/test-achievements.js b/scripts/test-achievements.js
new file mode 100644
index 0000000..a815186
--- /dev/null
+++ b/scripts/test-achievements.js
@@ -0,0 +1,50 @@
+/**
+ * Test Script für das JavaScript Achievement System
+ * 
+ * Testet die Achievement-Logik ohne auf 19:00 Uhr zu warten
+ */
+
+const AchievementSystem = require('../lib/achievementSystem');
+require('dotenv').config();
+
+async function testAchievementSystem() {
+    console.log('🧪 Starte Achievement-System Test...\n');
+    
+    try {
+        const achievementSystem = new AchievementSystem();
+        
+        // Lade Achievements
+        console.log('📋 Lade Achievements...');
+        await achievementSystem.loadAchievements();
+        
+        // Führe tägliche Achievement-Prüfung durch
+        console.log('\n🎯 Führe tägliche Achievement-Prüfung durch...');
+        const result = await achievementSystem.runDailyAchievementCheck();
+        
+        // Zeige Ergebnisse
+        console.log('\n📊 Test-Ergebnisse:');
+        console.log(`   🏆 ${result.totalNewAchievements} neue Achievements vergeben`);
+        console.log(`   👥 ${result.playerAchievements.length} Spieler haben neue Achievements erhalten`);
+        
+        if (result.playerAchievements.length > 0) {
+            console.log('\n📋 Neue Achievements im Detail:');
+            result.playerAchievements.forEach(player => {
+                console.log(`   👤 ${player.player}:`);
+                player.achievements.forEach(achievement => {
+                    console.log(`      ${achievement.icon} ${achievement.name} (+${achievement.points} Punkte)`);
+                });
+            });
+        } else {
+            console.log('\nℹ️  Keine neuen Achievements vergeben');
+        }
+        
+        console.log('\n✅ Test erfolgreich abgeschlossen!');
+        
+    } catch (error) {
+        console.error('❌ Test fehlgeschlagen:', error);
+        process.exit(1);
+    }
+}
+
+// Führe Test aus
+testAchievementSystem();
diff --git a/scripts/test-immediate-achievements.js b/scripts/test-immediate-achievements.js
new file mode 100644
index 0000000..48c0681
--- /dev/null
+++ b/scripts/test-immediate-achievements.js
@@ -0,0 +1,48 @@
+/**
+ * Test Script für sofortige Achievements
+ * 
+ * Testet die sofortige Achievement-Logik für einen einzelnen Spieler
+ */
+
+const AchievementSystem = require('../lib/achievementSystem');
+require('dotenv').config();
+
+async function testImmediateAchievements() {
+    console.log('⚡ Starte sofortige Achievement-Test...\n');
+    
+    try {
+        const achievementSystem = new AchievementSystem();
+        
+        // Lade Achievements
+        console.log('📋 Lade Achievements...');
+        await achievementSystem.loadAchievements();
+        
+        // Teste mit einem spezifischen Spieler (Carsten Graf)
+        const testPlayerId = '313ceee3-8040-44b4-98d2-e63703579e5d';
+        
+        console.log(`\n🎯 Teste sofortige Achievements für Spieler ${testPlayerId}...`);
+        const newAchievements = await achievementSystem.checkImmediateAchievements(testPlayerId);
+        
+        // Zeige Ergebnisse
+        console.log('\n📊 Sofortige Achievement-Test Ergebnisse:');
+        console.log(`   🏆 ${newAchievements.length} neue sofortige Achievements vergeben`);
+        
+        if (newAchievements.length > 0) {
+            console.log('\n📋 Neue sofortige Achievements:');
+            newAchievements.forEach(achievement => {
+                console.log(`   ${achievement.icon} ${achievement.name} (+${achievement.points} Punkte)`);
+            });
+        } else {
+            console.log('\nℹ️  Keine neuen sofortigen Achievements vergeben');
+        }
+        
+        console.log('\n✅ Sofortige Achievement-Test erfolgreich abgeschlossen!');
+        
+    } catch (error) {
+        console.error('❌ Test fehlgeschlagen:', error);
+        process.exit(1);
+    }
+}
+
+// Führe Test aus
+testImmediateAchievements();
diff --git a/scripts/test-multiple-achievements.js b/scripts/test-multiple-achievements.js
new file mode 100644
index 0000000..caa6937
--- /dev/null
+++ b/scripts/test-multiple-achievements.js
@@ -0,0 +1,75 @@
+/**
+ * Test Script für mehrfache Achievements
+ * 
+ * Demonstriert, wie Achievements mehrmals erreicht werden können
+ * und wie die Gesamtpunkte berechnet werden
+ */
+
+const AchievementSystem = require('../lib/achievementSystem');
+require('dotenv').config();
+
+async function testMultipleAchievements() {
+    console.log('🔄 Teste mehrfache Achievements...\n');
+    
+    try {
+        const achievementSystem = new AchievementSystem();
+        
+        // Lade Achievements
+        console.log('📋 Lade Achievements...');
+        await achievementSystem.loadAchievements();
+        
+        // Teste mit Carsten Graf
+        const testPlayerId = '313ceee3-8040-44b4-98d2-e63703579e5d';
+        
+        console.log(`\n👤 Teste mit Spieler: ${testPlayerId}`);
+        
+        // Zeige aktuelle Punkte
+        console.log('\n📊 Aktuelle Gesamtpunkte:');
+        const currentPoints = await achievementSystem.getPlayerTotalPoints(testPlayerId);
+        console.log(`   🏆 Gesamtpunkte: ${currentPoints.totalPoints}`);
+        console.log(`   🔢 Gesamt-Completions: ${currentPoints.totalCompletions}`);
+        
+        // Führe Achievement-Check durch
+        console.log('\n🎯 Führe Achievement-Check durch...');
+        const newAchievements = await achievementSystem.checkImmediateAchievements(testPlayerId);
+        
+        if (newAchievements.length > 0) {
+            console.log(`\n🏆 ${newAchievements.length} neue Achievements vergeben:`);
+            newAchievements.forEach(achievement => {
+                console.log(`   ${achievement.icon} ${achievement.name} (+${achievement.points} Punkte)`);
+            });
+        } else {
+            console.log('\nℹ️  Keine neuen Achievements vergeben');
+        }
+        
+        // Zeige neue Gesamtpunkte
+        console.log('\n📊 Neue Gesamtpunkte:');
+        const newPoints = await achievementSystem.getPlayerTotalPoints(testPlayerId);
+        console.log(`   🏆 Gesamtpunkte: ${newPoints.totalPoints} (${newPoints.totalPoints - currentPoints.totalPoints > 0 ? '+' : ''}${newPoints.totalPoints - currentPoints.totalPoints})`);
+        console.log(`   🔢 Gesamt-Completions: ${newPoints.totalCompletions} (${newPoints.totalCompletions - currentPoints.totalCompletions > 0 ? '+' : ''}${newPoints.totalCompletions - currentPoints.totalCompletions})`);
+        
+        // Zeige alle Achievements mit Completions
+        console.log('\n📋 Alle Achievements mit Completions:');
+        await achievementSystem.loadPlayerAchievements(testPlayerId);
+        const playerAchievements = achievementSystem.playerAchievements.get(testPlayerId);
+        
+        if (playerAchievements && playerAchievements.size > 0) {
+            for (const [achievementId, data] of playerAchievements) {
+                const achievement = Array.from(achievementSystem.achievements.values())
+                    .find(a => a.id === achievementId);
+                if (achievement) {
+                    console.log(`   ${achievement.icon} ${achievement.name}: ${data.completion_count}x (${data.completion_count * achievement.points} Punkte)`);
+                }
+            }
+        }
+        
+        console.log('\n✅ Mehrfache Achievement-Test erfolgreich abgeschlossen!');
+        
+    } catch (error) {
+        console.error('❌ Test fehlgeschlagen:', error);
+        process.exit(1);
+    }
+}
+
+// Führe Test aus
+testMultipleAchievements();
diff --git a/server.js b/server.js
new file mode 100644
index 0000000..0c9271f
--- /dev/null
+++ b/server.js
@@ -0,0 +1,380 @@
+/**
+ * NinjaCross Leaderboard Server
+ * 
+ * Hauptserver für das NinjaCross Timer-System mit:
+ * - Express.js Web-Server
+ * - Socket.IO für Real-time Updates
+ * - PostgreSQL Datenbankanbindung
+ * - API-Key Authentifizierung
+ * - Session-basierte Web-Authentifizierung
+ * 
+ * @author NinjaCross Team
+ * @version 1.0.0
+ */
+
+// ============================================================================
+// DEPENDENCIES & IMPORTS
+// ============================================================================
+
+const express = require('express');
+const path = require('path');
+const session = require('express-session');
+const { createServer } = require('http');
+const { Server } = require('socket.io');
+const swaggerUi = require('swagger-ui-express');
+const swaggerSpecs = require('./swagger');
+const cron = require('node-cron');
+require('dotenv').config();
+
+// Route Imports
+const { router: apiRoutes, requireApiKey } = require('./routes/api');
+
+// Achievement System
+const AchievementSystem = require('./lib/achievementSystem');
+
+// ============================================================================
+// SERVER CONFIGURATION
+// ============================================================================
+
+const app = express();
+const server = createServer(app);
+const port = process.env.PORT || 3000;
+
+// Socket.IO Configuration
+const io = new Server(server, {
+    cors: {
+        origin: "*",
+        methods: ["GET", "POST"]
+    }
+});
+
+// ============================================================================
+// MIDDLEWARE SETUP
+// ============================================================================
+
+// CORS Configuration - Allow all origins for development
+app.use((req, res, next) => {
+    // Allow specific origins when credentials are needed
+    const origin = req.headers.origin;
+    if (origin && (origin.includes('ninja.reptilfpv.de') || origin.includes('localhost') || origin.includes('127.0.0.1'))) {
+        res.setHeader('Access-Control-Allow-Origin', origin);
+        res.setHeader('Access-Control-Allow-Credentials', 'true'); // Allow cookies
+    } else {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+    }
+    
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS, PATCH');
+    res.setHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization, X-API-Key');
+    res.setHeader('Access-Control-Max-Age', '86400'); // 24 hours
+
+    // Handle preflight requests
+    if (req.method === 'OPTIONS') {
+        res.status(200).end();
+        return;
+    }
+
+    next();
+});
+
+// Body Parser Middleware
+app.use(express.json({ limit: '10mb' }));
+app.use(express.urlencoded({ extended: true, limit: '10mb' }));
+
+// Session Configuration
+app.use(session({
+    secret: process.env.SESSION_SECRET || 'kjhdizr3lhwho8fpjslgf825ß0hsd',
+    resave: false,
+    saveUninitialized: false,
+    cookie: {
+        secure: false, // Set to true when using HTTPS
+        maxAge: 24 * 60 * 60 * 1000, // 24 hours
+        httpOnly: true, // Security: prevent XSS attacks
+        sameSite: 'lax' // Allow cookies in cross-origin requests
+    }
+}));
+
+
+// ============================================================================
+// AUTHENTICATION MIDDLEWARE
+// ============================================================================
+
+/**
+ * Web Interface Authentication Middleware
+ * Überprüft ob der Benutzer für das Web-Interface authentifiziert ist
+ */
+function requireWebAuth(req, res, next) {
+    if (req.session.userId) {
+        next();
+    } else {
+        res.redirect('/login');
+    }
+}
+
+// ============================================================================
+// ROUTE SETUP
+// ============================================================================
+
+// Swagger API Documentation
+app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs, {
+    customCss: '.swagger-ui .topbar { display: none }',
+    customSiteTitle: 'Ninja Cross Parkour API Documentation'
+}));
+
+// Unified API Routes (all under /api/v1/)
+// - /api/v1/public/* - Public routes (no authentication)
+// - /api/v1/private/* - API-Key protected routes
+// - /api/v1/web/* - Session protected routes
+// - /api/v1/admin/* - Admin protected routes
+app.use('/api', apiRoutes);
+
+// ============================================================================
+// WEB INTERFACE ROUTES
+// ============================================================================
+
+/**
+ * Public Landing Page - NinjaCross Leaderboard
+ * Hauptseite mit dem öffentlichen Leaderboard
+ */
+app.get('/', (req, res) => {
+    res.sendFile(path.join(__dirname, 'public', 'index.html'));
+});
+
+/**
+ * Admin Dashboard Page
+ * Hauptdashboard für Admin-Benutzer
+ */
+app.get('/admin-dashboard', (req, res) => {
+    res.sendFile(path.join(__dirname, 'public', 'admin-dashboard.html'));
+});
+
+/**
+ * Admin Generator Page
+ * Geschützte Seite für die Lizenz-Generierung (Level 2 Zugriff erforderlich)
+ */
+app.get('/generator', requireWebAuth, (req, res) => {
+    // Prüfe Zugriffslevel für Generator
+    if (req.session.accessLevel < 2) {
+        return res.status(403).send(`
+            <h1>Zugriff verweigert</h1>
+            <p>Sie benötigen Level 2 Zugriff für den Lizenzgenerator.</p>
+            <a href="/admin-dashboard">Zurück zum Dashboard</a>
+        `);
+    }
+    res.sendFile(path.join(__dirname, 'public', 'generator.html'));
+});
+
+/**
+ * Login Page
+ * Authentifizierungsseite für Admin-Benutzer
+ */
+app.get('/login', (req, res) => {
+    // Redirect to main page if already authenticated
+    if (req.session.userId) {
+        return res.redirect('/');
+    }
+    res.sendFile(path.join(__dirname, 'public', 'login.html'));
+});
+
+/**
+ * Admin Dashboard Page
+ * Dashboard-Seite für eingeloggte Administratoren
+ * Authentifizierung wird client-side über Supabase gehandhabt
+ */
+app.get('/dashboard', (req, res) => {
+    res.sendFile(path.join(__dirname, 'public', 'dashboard.html'));
+});
+
+/**
+ * Reset Password Page
+ * Seite für das Zurücksetzen von Passwörtern über Supabase
+ * Wird von Supabase E-Mail-Links aufgerufen
+ */
+app.get('/reset-password.html', (req, res) => {
+    res.sendFile(path.join(__dirname, 'public', 'reset-password.html'));
+});
+
+/**
+ * Admin Login Page
+ * Lizenzgenerator Login-Seite für Admin-Benutzer
+ */
+app.get('/adminlogin.html', (req, res) => {
+    res.sendFile(path.join(__dirname, 'public', 'adminlogin.html'));
+});
+
+/**
+ * OAuth Callback Route
+ * Handles OAuth redirects from Supabase (Google, etc.)
+ */
+app.get('/auth/callback', (req, res) => {
+    // Redirect to the main page after OAuth callback
+    // Supabase handles the OAuth flow and redirects here
+    res.redirect('/');
+});
+
+// ============================================================================
+// STATIC FILE SERVING
+// ============================================================================
+
+// Serve static files directly from public directory
+app.use(express.static('public'));
+
+// Serve static files for public pages (CSS, JS, images) - legacy route
+app.use('/public', express.static('public'));
+
+// Serve static files for login page
+app.use('/login', express.static('public'));
+
+// ============================================================================
+// WEBSOCKET CONFIGURATION
+// ============================================================================
+
+/**
+ * WebSocket Connection Handler
+ * Verwaltet Real-time Verbindungen für Live-Updates
+ */
+io.on('connection', (socket) => {
+    // Client connected - connection is established
+
+    socket.on('disconnect', () => {
+        // Client disconnected - cleanup if needed
+    });
+});
+
+// Make Socket.IO instance available to other modules
+app.set('io', io);
+
+// ============================================================================
+// ERROR HANDLING
+// ============================================================================
+
+// 404 Handler
+app.use('*', (req, res) => {
+    // Check if it's an API request
+    if (req.originalUrl.startsWith('/api/')) {
+        res.status(404).json({
+            success: false,
+            message: 'Route not found',
+            path: req.originalUrl
+        });
+    } else {
+        // Serve custom 404 page for non-API requests
+        res.status(404).sendFile(path.join(__dirname, 'public', '404.html'));
+    }
+});
+
+// Global Error Handler
+app.use((err, req, res, next) => {
+    console.error('Server Error:', err);
+    res.status(500).json({
+        success: false,
+        message: 'Internal server error'
+    });
+});
+
+// ============================================================================
+// SERVER STARTUP
+// ============================================================================
+
+/**
+ * Start the server and initialize all services
+ */
+server.listen(port, () => {
+    console.log(`🚀 Server läuft auf http://ninja.reptilfpv.de:${port}`);
+    console.log(`📊 Datenbank: ${process.env.DB_HOST}:${process.env.DB_PORT}/${process.env.DB_NAME}`);
+    console.log(`🔐 API-Key Authentifizierung aktiviert`);
+    console.log(`🔌 WebSocket-Server aktiviert`);
+    console.log(`📁 Static files: /public`);
+    console.log(`🌐 Unified API: /api/v1/`);
+    console.log(`   📖 Public: /api/v1/public/`);
+    console.log(`   🔒 Private: /api/v1/private/`);
+    console.log(`   🔐 Web: /api/v1/web/`);
+    console.log(`   👑 Admin: /api/v1/admin/`);
+});
+
+// ============================================================================
+// SCHEDULED TASKS
+// ============================================================================
+
+/**
+ * Scheduled Function - Runs daily at 7 PM (19:00)
+ * Führt tägliche Achievement-Prüfung durch
+ */
+async function scheduledTaskAt7PM() {
+    const now = new Date();
+    console.log(`⏰ Geplante Aufgabe ausgeführt um ${now.toLocaleString('de-DE')}`);
+    
+    try {
+        // Initialisiere Achievement-System
+        const achievementSystem = new AchievementSystem();
+        
+        // Führe tägliche Achievement-Prüfung durch
+        const result = await achievementSystem.runDailyAchievementCheck();
+        
+        console.log(`🏆 Achievement-Prüfung abgeschlossen:`);
+        console.log(`   📊 ${result.totalNewAchievements} neue Achievements vergeben`);
+        console.log(`   👥 ${result.playerAchievements.length} Spieler haben neue Achievements erhalten`);
+        
+        // Zeige Details der neuen Achievements
+        if (result.playerAchievements.length > 0) {
+            console.log(`\n📋 Neue Achievements im Detail:`);
+            result.playerAchievements.forEach(player => {
+                console.log(`   👤 ${player.player}:`);
+                player.achievements.forEach(achievement => {
+                    console.log(`      ${achievement.icon} ${achievement.name} (+${achievement.points} Punkte)`);
+                });
+            });
+        }
+        
+        console.log('✅ Geplante Aufgabe erfolgreich abgeschlossen');
+    } catch (error) {
+        console.error('❌ Fehler bei der geplanten Aufgabe:', error);
+    }
+}
+
+// Cron Job: Täglich um 19:00 Uhr (7 PM)
+// Format: Sekunde Minute Stunde Tag Monat Wochentag
+cron.schedule('0 0 19 * * *', scheduledTaskAt7PM, {
+    scheduled: true,
+    timezone: "Europe/Berlin" // Deutsche Zeitzone
+});
+
+console.log('📅 Geplante Aufgabe eingerichtet: Täglich um 19:00 Uhr');
+
+// ============================================================================
+// GRACEFUL SHUTDOWN
+// ============================================================================
+
+/**
+ * Handle graceful shutdown on SIGINT (Ctrl+C)
+ */
+process.on('SIGINT', async () => {
+    console.log('\n🛑 Server wird heruntergefahren...');
+
+    // Close server gracefully
+    server.close(() => {
+        console.log('✅ Server erfolgreich heruntergefahren');
+        process.exit(0);
+    });
+
+    // Force exit after 5 seconds if graceful shutdown fails
+    setTimeout(() => {
+        console.log('⚠️ Forced shutdown after timeout');
+        process.exit(1);
+    }, 5000);
+});
+
+/**
+ * Handle uncaught exceptions
+ */
+process.on('uncaughtException', (err) => {
+    console.error('Uncaught Exception:', err);
+    process.exit(1);
+});
+
+/**
+ * Handle unhandled promise rejections
+ */
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+    process.exit(1);
+});
\ No newline at end of file
diff --git a/ssl-setup-guide.md b/ssl-setup-guide.md
new file mode 100644
index 0000000..e39aea8
--- /dev/null
+++ b/ssl-setup-guide.md
@@ -0,0 +1,89 @@
+# SSL Setup für NinjaCross Server
+
+## 1. Let's Encrypt SSL Zertifikat installieren
+
+```bash
+# Certbot installieren (Ubuntu/Debian)
+sudo apt update
+sudo apt install certbot python3-certbot-apache
+
+# SSL Zertifikat anfordern
+sudo certbot certonly --standalone -d ninja.reptilfpv.de
+
+# Automatische Erneuerung einrichten
+sudo crontab -e
+# Füge hinzu: 0 12 * * * /usr/bin/certbot renew --quiet
+```
+
+## 2. Apache Module aktivieren
+
+```bash
+# Notwendige Apache Module aktivieren
+sudo a2enmod ssl
+sudo a2enmod proxy
+sudo a2enmod proxy_http
+sudo a2enmod proxy_wstunnel
+sudo a2enmod headers
+sudo a2enmod rewrite
+
+# Apache neustarten
+sudo systemctl restart apache2
+```
+
+## 3. VirtualHost konfigurieren
+
+```bash
+# SSL Konfiguration kopieren
+sudo cp apache-ssl-config.conf /etc/apache2/sites-available/ninjaserver-ssl.conf
+
+# Site aktivieren
+sudo a2ensite ninjaserver-ssl.conf
+
+# Standard-Site deaktivieren (optional)
+sudo a2dissite 000-default.conf
+
+# Apache Konfiguration testen
+sudo apache2ctl configtest
+
+# Apache neuladen
+sudo systemctl reload apache2
+```
+
+## 4. Node.js Server anpassen (optional)
+
+Ihr Node.js Server läuft weiterhin auf Port 3000 (localhost only).
+Optional können Sie den Server auf localhost binden:
+
+```javascript
+// In server.js
+server.listen(port, 'localhost', () => {
+    console.log(`🚀 Server läuft auf http://localhost:${port}`);
+    console.log(`🔒 HTTPS verfügbar über Apache Proxy`);
+});
+```
+
+## 5. Firewall anpassen
+
+```bash
+# HTTPS Port öffnen
+sudo ufw allow 443/tcp
+sudo ufw allow 80/tcp
+
+# Port 3000 nur für localhost (Sicherheit)
+sudo ufw deny 3000
+```
+
+## 6. Testen
+
+1. Öffne https://ninja.reptilfpv.de
+2. Teste QR-Scanner → Kamera sollte funktionieren
+3. Prüfe SSL-Rating: https://www.ssllabs.com/ssltest/
+
+## Vorteile dieser Lösung:
+
+✅ **Automatische SSL-Erneuerung** mit Let's Encrypt
+✅ **Hohe Performance** durch Apache SSL-Terminierung  
+✅ **Security Headers** für zusätzlichen Schutz
+✅ **WebSocket Support** für Live-Updates
+✅ **HTTP → HTTPS Redirect** automatisch
+✅ **Kamera-Zugriff** funktioniert in allen Browsern
diff --git a/swagger.js b/swagger.js
new file mode 100644
index 0000000..04c8b82
--- /dev/null
+++ b/swagger.js
@@ -0,0 +1,285 @@
+const swaggerJsdoc = require('swagger-jsdoc');
+
+const options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      title: 'Ninja Cross Parkour API',
+      version: '1.0.0',
+      description: 'API für das Ninja Cross Parkour System im Schwimmbad',
+      contact: {
+        name: 'Ninja Cross Parkour',
+        email: 'admin@ninjacross.com'
+      },
+      license: {
+        name: 'MIT',
+        url: 'https://opensource.org/licenses/MIT'
+      }
+    },
+    servers: [
+      {
+        url: 'https://ninja.reptilfpv.de',
+        description: 'Production server'
+      }
+    ],
+    components: {
+      securitySchemes: {
+        ApiKeyAuth: {
+          type: 'apiKey',
+          in: 'header',
+          name: 'X-API-Key',
+          description: 'API Key für Authentifizierung'
+        },
+        BearerAuth: {
+          type: 'http',
+          scheme: 'bearer',
+          bearerFormat: 'JWT',
+          description: 'JWT Token für Supabase Authentifizierung'
+        }
+      },
+      schemas: {
+        Player: {
+          type: 'object',
+          properties: {
+            id: {
+              type: 'string',
+              format: 'uuid',
+              description: 'Eindeutige Spieler-ID'
+            },
+            firstname: {
+              type: 'string',
+              description: 'Vorname des Spielers'
+            },
+            lastname: {
+              type: 'string',
+              description: 'Nachname des Spielers'
+            },
+            birthdate: {
+              type: 'string',
+              format: 'date',
+              description: 'Geburtsdatum des Spielers'
+            },
+            rfiduid: {
+              type: 'string',
+              description: 'RFID UID der Karte (Format: XX:XX:XX:XX)'
+            },
+            supabase_user_id: {
+              type: 'string',
+              format: 'uuid',
+              description: 'Supabase User ID für Verknüpfung'
+            },
+            created_at: {
+              type: 'string',
+              format: 'date-time',
+              description: 'Erstellungsdatum'
+            }
+          }
+        },
+        Time: {
+          type: 'object',
+          properties: {
+            id: {
+              type: 'string',
+              format: 'uuid',
+              description: 'Eindeutige Zeit-ID'
+            },
+            player_id: {
+              type: 'string',
+              format: 'uuid',
+              description: 'ID des Spielers'
+            },
+            location_id: {
+              type: 'string',
+              format: 'uuid',
+              description: 'ID des Standorts'
+            },
+            recorded_time: {
+              type: 'object',
+              description: 'Aufgezeichnete Zeit als Intervall',
+              properties: {
+                seconds: { type: 'number' },
+                minutes: { type: 'number' },
+                milliseconds: { type: 'number' }
+              }
+            },
+            created_at: {
+              type: 'string',
+              format: 'date-time',
+              description: 'Erstellungsdatum'
+            }
+          }
+        },
+        Location: {
+          type: 'object',
+          properties: {
+            id: {
+              type: 'string',
+              format: 'uuid',
+              description: 'Eindeutige Standort-ID'
+            },
+            name: {
+              type: 'string',
+              description: 'Name des Standorts'
+            },
+            latitude: {
+              type: 'number',
+              format: 'float',
+              description: 'Breitengrad'
+            },
+            longitude: {
+              type: 'number',
+              format: 'float',
+              description: 'Längengrad'
+            },
+            time_threshold: {
+              type: 'object',
+              description: 'Zeitschwelle für den Standort',
+              properties: {
+                seconds: { type: 'number' },
+                minutes: { type: 'number' }
+              }
+            },
+            created_at: {
+              type: 'string',
+              format: 'date-time',
+              description: 'Erstellungsdatum'
+            }
+          }
+        },
+        Achievement: {
+          type: 'object',
+          properties: {
+            id: {
+              type: 'string',
+              format: 'uuid',
+              description: 'Eindeutige Achievement-ID'
+            },
+            name: {
+              type: 'string',
+              description: 'Name des Achievements'
+            },
+            description: {
+              type: 'string',
+              description: 'Beschreibung des Achievements'
+            },
+            category: {
+              type: 'string',
+              enum: ['consistency', 'improvement', 'seasonal', 'monthly'],
+              description: 'Kategorie des Achievements'
+            },
+            condition_type: {
+              type: 'string',
+              description: 'Typ der Bedingung'
+            },
+            condition_value: {
+              type: 'integer',
+              description: 'Wert der Bedingung'
+            },
+            icon: {
+              type: 'string',
+              description: 'Emoji-Icon für das Achievement'
+            },
+            points: {
+              type: 'integer',
+              description: 'Punkte für das Achievement'
+            },
+            is_active: {
+              type: 'boolean',
+              description: 'Ob das Achievement aktiv ist'
+            }
+          }
+        },
+        PlayerAchievement: {
+          type: 'object',
+          properties: {
+            id: {
+              type: 'string',
+              format: 'uuid',
+              description: 'Eindeutige Player-Achievement-ID'
+            },
+            player_id: {
+              type: 'string',
+              format: 'uuid',
+              description: 'ID des Spielers'
+            },
+            achievement_id: {
+              type: 'string',
+              format: 'uuid',
+              description: 'ID des Achievements'
+            },
+            progress: {
+              type: 'integer',
+              description: 'Aktueller Fortschritt'
+            },
+            is_completed: {
+              type: 'boolean',
+              description: 'Ob das Achievement abgeschlossen ist'
+            },
+            earned_at: {
+              type: 'string',
+              format: 'date-time',
+              description: 'Wann das Achievement erreicht wurde'
+            }
+          }
+        },
+        Error: {
+          type: 'object',
+          properties: {
+            success: {
+              type: 'boolean',
+              example: false
+            },
+            message: {
+              type: 'string',
+              description: 'Fehlermeldung'
+            }
+          }
+        },
+        Success: {
+          type: 'object',
+          properties: {
+            success: {
+              type: 'boolean',
+              example: true
+            },
+            message: {
+              type: 'string',
+              description: 'Erfolgsmeldung'
+            },
+            data: {
+              type: 'object',
+              description: 'Daten der Antwort'
+            }
+          }
+        }
+      }
+    },
+    tags: [
+      {
+        name: 'Public API',
+        description: 'Öffentliche API-Endpoints ohne Authentifizierung'
+      },
+      {
+        name: 'Private API',
+        description: 'Private API-Endpoints mit API-Key Authentifizierung'
+      },
+      {
+        name: 'Web API',
+        description: 'Web-API-Endpoints für das Frontend'
+      },
+      {
+        name: 'Admin API',
+        description: 'Admin-API-Endpoints für Verwaltung'
+      },
+      {
+        name: 'Achievements',
+        description: 'Achievement-System Endpoints'
+      }
+    ]
+  },
+  apis: ['./routes/api.js'] // Pfad zu deiner API-Datei
+};
+
+const specs = swaggerJsdoc(options);
+
+module.exports = specs;
diff --git a/test-achievements.js b/test-achievements.js
new file mode 100644
index 0000000..1838d6d
--- /dev/null
+++ b/test-achievements.js
@@ -0,0 +1,46 @@
+const AchievementSystem = require('./lib/achievementSystem');
+
+async function testAchievements() {
+    console.log('=== Testing Achievement System ===');
+    
+    const achievementSystem = new AchievementSystem();
+    const playerId = '08476bfc-5f48-486c-9f0b-90b81e5ccd8d';
+    
+    try {
+        // Test 1: Load achievements
+        console.log('\n1. Loading achievements...');
+        await achievementSystem.loadAchievements();
+        console.log(`✅ Loaded ${achievementSystem.achievements.size} achievements`);
+        
+        // Test 2: Load player achievements
+        console.log('\n2. Loading player achievements...');
+        await achievementSystem.loadPlayerAchievements(playerId);
+        const playerAchievements = achievementSystem.playerAchievements.get(playerId);
+        console.log(`✅ Player has ${playerAchievements ? playerAchievements.size : 0} achievements`);
+        
+        // Test 3: Check first time achievement
+        console.log('\n3. Checking first time achievement...');
+        const firstTimeAchievement = Array.from(achievementSystem.achievements.values())
+            .find(a => a.category === 'consistency' && a.condition_type === 'first_time');
+        console.log('First time achievement:', firstTimeAchievement ? firstTimeAchievement.name : 'NOT FOUND');
+        
+        // Test 4: Check September achievement
+        console.log('\n4. Checking September achievement...');
+        const septemberAchievement = Array.from(achievementSystem.achievements.values())
+            .find(a => a.category === 'monthly' && a.condition_type === 'september');
+        console.log('September achievement:', septemberAchievement ? septemberAchievement.name : 'NOT FOUND');
+        
+        // Test 5: Check immediate achievements
+        console.log('\n5. Running immediate achievement check...');
+        const newAchievements = await achievementSystem.checkImmediateAchievements(playerId);
+        console.log(`✅ Found ${newAchievements.length} new achievements`);
+        newAchievements.forEach(achievement => {
+            console.log(`   🏆 ${achievement.name} (+${achievement.points} points)`);
+        });
+        
+    } catch (error) {
+        console.error('❌ Error:', error);
+    }
+}
+
+testAchievements();
diff --git a/wiki/API-Referenz.md b/wiki/API-Referenz.md
new file mode 100644
index 0000000..92a25ea
--- /dev/null
+++ b/wiki/API-Referenz.md
@@ -0,0 +1,752 @@
+# 📡 API Referenz
+
+Vollständige Dokumentation der REST API des Ninja Cross Parkour Systems.
+
+## 📋 Inhaltsverzeichnis
+
+- [🔐 Authentifizierung](#-authentifizierung)
+- [🌐 Public API](#-public-api)
+- [🔒 Private API](#-private-api)
+- [🖥️ Web API](#️-web-api)
+- [👑 Admin API](#-admin-api)
+- [🏆 Achievements API](#-achievements-api)
+- [📊 Datenmodelle](#-datenmodelle)
+- [❌ Fehlerbehandlung](#-fehlerbehandlung)
+
+## 🔐 Authentifizierung
+
+### API-Key Authentifizierung
+Für private Endpoints wird ein API-Key im Authorization Header benötigt:
+
+```http
+Authorization: Bearer YOUR_API_KEY_HERE
+```
+
+### Session-basierte Authentifizierung
+Für Web-Endpoints wird eine Session-basierte Authentifizierung verwendet.
+
+### Admin-Authentifizierung
+Für Admin-Endpoints wird eine erweiterte Authentifizierung mit Admin-Rechten benötigt.
+
+## 🌐 Public API
+
+Öffentliche Endpoints ohne Authentifizierung.
+
+### 🔑 Authentifizierung
+
+#### Login
+```http
+POST /api/v1/public/login
+Content-Type: application/json
+
+{
+  "username": "admin",
+  "password": "admin123"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Login erfolgreich",
+  "user": {
+    "id": 1,
+    "username": "admin",
+    "is_active": true
+  }
+}
+```
+
+#### Logout
+```http
+POST /api/v1/public/logout
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Logout erfolgreich"
+}
+```
+
+### 👥 Spieler Management
+
+#### Spieler erstellen
+```http
+POST /api/v1/public/players
+Content-Type: application/json
+
+{
+  "firstname": "Max",
+  "lastname": "Mustermann",
+  "birthdate": "1990-01-01",
+  "rfiduid": "AA:BB:CC:DD"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "data": {
+    "id": "uuid",
+    "firstname": "Max",
+    "lastname": "Mustermann",
+    "birthdate": "1990-01-01",
+    "rfiduid": "AA:BB:CC:DD",
+    "created_at": "2024-01-01T00:00:00Z"
+  }
+}
+```
+
+#### Spieler verknüpfen
+```http
+POST /api/v1/public/link-player
+Content-Type: application/json
+
+{
+  "rfiduid": "AA:BB:CC:DD",
+  "supabase_user_id": "uuid-here"
+}
+```
+
+#### Spieler per RFID verknüpfen
+```http
+POST /api/v1/public/link-by-rfid
+Content-Type: application/json
+
+{
+  "rfiduid": "AA:BB:CC:DD",
+  "supabase_user_id": "uuid-here"
+}
+```
+
+### 📍 Standorte
+
+#### Alle Standorte abrufen
+```http
+GET /api/v1/public/locations
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "data": [
+    {
+      "id": "uuid",
+      "name": "Standort 1",
+      "latitude": 48.1351,
+      "longitude": 11.5820,
+      "time_threshold": {
+        "seconds": 120
+      },
+      "created_at": "2024-01-01T00:00:00Z"
+    }
+  ]
+}
+```
+
+### ⏱️ Zeiten
+
+#### Alle Zeiten abrufen
+```http
+GET /api/v1/public/times
+```
+
+#### Zeiten mit Details abrufen
+```http
+GET /api/v1/public/times-with-details
+```
+
+#### Beste Zeiten abrufen
+```http
+GET /api/v1/public/best-times
+```
+
+#### Benutzer-Zeiten abrufen
+```http
+GET /api/v1/public/user-times/{supabase_user_id}
+```
+
+#### Benutzer-Spieler abrufen
+```http
+GET /api/v1/public/user-player/{supabase_user_id}
+```
+
+### 📊 Statistiken
+
+#### Seitenaufruf verfolgen
+```http
+POST /api/v1/public/track-page-view
+Content-Type: application/json
+
+{
+  "page": "/dashboard",
+  "user_agent": "Mozilla/5.0...",
+  "ip_address": "192.168.1.1"
+}
+```
+
+### 🔔 Push Notifications
+
+#### Push-Benachrichtigung abonnieren
+```http
+POST /api/v1/public/subscribe
+Content-Type: application/json
+
+{
+  "endpoint": "https://fcm.googleapis.com/fcm/send/...",
+  "keys": {
+    "p256dh": "key-here",
+    "auth": "auth-key-here"
+  }
+}
+```
+
+#### Push-Benachrichtigung testen
+```http
+POST /api/v1/public/test-push
+Content-Type: application/json
+
+{
+  "title": "Test",
+  "body": "Test-Nachricht",
+  "icon": "/icon.png"
+}
+```
+
+#### Push-Status abrufen
+```http
+GET /api/v1/public/push-status
+```
+
+## 🔒 Private API
+
+Private Endpoints mit API-Key Authentifizierung.
+
+### 🎫 Token Management
+
+#### Token speichern
+```http
+POST /api/v1/private/save-token
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "token": "GENERATED_TOKEN",
+  "description": "Beschreibung",
+  "standorte": "München, Berlin"
+}
+```
+
+#### Alle Token abrufen
+```http
+GET /api/v1/private/tokens
+Authorization: Bearer YOUR_API_KEY
+```
+
+#### Token validieren
+```http
+POST /api/v1/private/validate-token
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "token": "TOKEN_TO_VALIDATE"
+}
+```
+
+### 📍 Standort Management
+
+#### Standort erstellen
+```http
+POST /api/v1/private/create-location
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "name": "München",
+  "latitude": 48.1351,
+  "longitude": 11.5820
+}
+```
+
+#### Alle Standorte abrufen
+```http
+GET /api/v1/private/locations
+Authorization: Bearer YOUR_API_KEY
+```
+
+#### Standort-Schwelle aktualisieren
+```http
+PUT /api/v1/private/locations/{id}/threshold
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "threshold_seconds": 120
+}
+```
+
+### 👥 Spieler Management
+
+#### Spieler erstellen
+```http
+POST /api/v1/private/create-player
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "firstname": "Max",
+  "lastname": "Mustermann",
+  "birthdate": "1990-01-01",
+  "rfiduid": "AA:BB:CC:DD"
+}
+```
+
+#### Benutzer suchen
+```http
+POST /api/v1/private/users/find
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "search_term": "Max"
+}
+```
+
+### ⏱️ Zeit Management
+
+#### Zeit erstellen
+```http
+POST /api/v1/private/create-time
+Authorization: Bearer YOUR_API_KEY
+Content-Type: application/json
+
+{
+  "player_id": "RFIDUID",
+  "location_id": "Name",
+  "recorded_time": "01:23.456"
+}
+```
+
+## 🖥️ Web API
+
+Web-API-Endpoints für das Frontend.
+
+### 🔑 API-Key generieren
+```http
+POST /api/v1/web/generate-api-key
+Content-Type: application/json
+
+{
+  "description": "Mein API Key",
+  "standorte": "München, Berlin"
+}
+```
+
+### 📍 Standort erstellen
+```http
+POST /api/v1/web/create-location
+Content-Type: application/json
+
+{
+  "name": "München",
+  "latitude": 48.1351,
+  "longitude": 11.5820
+}
+```
+
+### 🎫 Token speichern
+```http
+POST /api/v1/web/save-token
+Content-Type: application/json
+
+{
+  "token": "GENERATED_TOKEN",
+  "description": "Beschreibung",
+  "standorte": "München, Berlin"
+}
+```
+
+### 🔍 Session prüfen
+```http
+GET /api/v1/web/check-session
+```
+
+## 👑 Admin API
+
+Admin-API-Endpoints für Verwaltung.
+
+### 📊 Statistiken
+
+#### Admin-Statistiken
+```http
+GET /api/v1/admin/stats
+Authorization: Bearer ADMIN_TOKEN
+```
+
+#### Seiten-Statistiken
+```http
+GET /api/v1/admin/page-stats
+Authorization: Bearer ADMIN_TOKEN
+```
+
+### 👥 Spieler Verwaltung
+
+#### Alle Spieler abrufen
+```http
+GET /api/v1/admin/players
+Authorization: Bearer ADMIN_TOKEN
+```
+
+#### Spieler erstellen
+```http
+POST /api/v1/admin/players
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "firstname": "Max",
+  "lastname": "Mustermann",
+  "birthdate": "1990-01-01",
+  "rfiduid": "AA:BB:CC:DD"
+}
+```
+
+#### Spieler aktualisieren
+```http
+PUT /api/v1/admin/players/{id}
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "firstname": "Max",
+  "lastname": "Mustermann",
+  "birthdate": "1990-01-01",
+  "rfiduid": "AA:BB:CC:DD"
+}
+```
+
+#### Spieler löschen
+```http
+DELETE /api/v1/admin/players/{id}
+Authorization: Bearer ADMIN_TOKEN
+```
+
+### 🏃‍♂️ Läufe Verwaltung
+
+#### Alle Läufe abrufen
+```http
+GET /api/v1/admin/runs
+Authorization: Bearer ADMIN_TOKEN
+```
+
+#### Lauf abrufen
+```http
+GET /api/v1/admin/runs/{id}
+Authorization: Bearer ADMIN_TOKEN
+```
+
+#### Lauf erstellen
+```http
+POST /api/v1/admin/runs
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "player_id": "uuid",
+  "location_id": "uuid",
+  "recorded_time": "01:23.456"
+}
+```
+
+#### Lauf aktualisieren
+```http
+PUT /api/v1/admin/runs/{id}
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "recorded_time": "01:20.000"
+}
+```
+
+#### Lauf löschen
+```http
+DELETE /api/v1/admin/runs/{id}
+Authorization: Bearer ADMIN_TOKEN
+```
+
+### 📍 Standort Verwaltung
+
+#### Alle Standorte abrufen
+```http
+GET /api/v1/admin/locations
+Authorization: Bearer ADMIN_TOKEN
+```
+
+#### Standort erstellen
+```http
+POST /api/v1/admin/locations
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "name": "München",
+  "latitude": 48.1351,
+  "longitude": 11.5820,
+  "time_threshold": 120
+}
+```
+
+#### Standort aktualisieren
+```http
+PUT /api/v1/admin/locations/{id}
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "name": "München Updated",
+  "latitude": 48.1351,
+  "longitude": 11.5820,
+  "time_threshold": 120
+}
+```
+
+#### Standort löschen
+```http
+DELETE /api/v1/admin/locations/{id}
+Authorization: Bearer ADMIN_TOKEN
+```
+
+### 👤 Admin-Benutzer Verwaltung
+
+#### Alle Admin-Benutzer abrufen
+```http
+GET /api/v1/admin/adminusers
+Authorization: Bearer ADMIN_TOKEN
+```
+
+#### Admin-Benutzer erstellen
+```http
+POST /api/v1/admin/adminusers
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "username": "newadmin",
+  "password": "securepassword"
+}
+```
+
+#### Admin-Benutzer aktualisieren
+```http
+PUT /api/v1/admin/adminusers/{id}
+Authorization: Bearer ADMIN_TOKEN
+Content-Type: application/json
+
+{
+  "username": "updatedadmin",
+  "is_active": true
+}
+```
+
+#### Admin-Benutzer löschen
+```http
+DELETE /api/v1/admin/adminusers/{id}
+Authorization: Bearer ADMIN_TOKEN
+```
+
+## 🏆 Achievements API
+
+Achievement-System Endpoints.
+
+### 🏆 Achievements abrufen
+```http
+GET /api/achievements
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "data": [
+    {
+      "id": "uuid",
+      "name": "Erster Lauf",
+      "description": "Absolviere deinen ersten Lauf",
+      "category": "consistency",
+      "condition_type": "runs_count",
+      "condition_value": 1,
+      "icon": "🏃‍♂️",
+      "points": 10,
+      "is_active": true
+    }
+  ]
+}
+```
+
+### 👤 Spieler-Achievements
+```http
+GET /api/achievements/player/{playerId}
+```
+
+### 📊 Spieler-Statistiken
+```http
+GET /api/achievements/player/{playerId}/stats
+```
+
+### ✅ Achievement prüfen
+```http
+POST /api/achievements/check/{playerId}
+Content-Type: application/json
+
+{
+  "achievement_id": "uuid"
+}
+```
+
+### 📅 Tägliche Prüfung
+```http
+POST /api/achievements/daily-check
+```
+
+### 🏃‍♂️ Beste Zeit prüfen
+```http
+POST /api/achievements/best-time-check
+```
+
+### 🏅 Leaderboard
+```http
+GET /api/achievements/leaderboard
+```
+
+## 📊 Datenmodelle
+
+### Player
+```json
+{
+  "id": "string (uuid)",
+  "firstname": "string",
+  "lastname": "string",
+  "birthdate": "string (date)",
+  "rfiduid": "string (XX:XX:XX:XX)",
+  "supabase_user_id": "string (uuid)",
+  "created_at": "string (date-time)"
+}
+```
+
+### Time
+```json
+{
+  "id": "string (uuid)",
+  "player_id": "string (uuid)",
+  "location_id": "string (uuid)",
+  "recorded_time": {
+    "seconds": "number",
+    "minutes": "number",
+    "milliseconds": "number"
+  },
+  "created_at": "string (date-time)"
+}
+```
+
+### Location
+```json
+{
+  "id": "string (uuid)",
+  "name": "string",
+  "latitude": "number (float)",
+  "longitude": "number (float)",
+  "time_threshold": {
+    "seconds": "number",
+    "minutes": "number"
+  },
+  "created_at": "string (date-time)"
+}
+```
+
+### Achievement
+```json
+{
+  "id": "string (uuid)",
+  "name": "string",
+  "description": "string",
+  "category": "string (consistency|improvement|seasonal|monthly)",
+  "condition_type": "string",
+  "condition_value": "integer",
+  "icon": "string (emoji)",
+  "points": "integer",
+  "is_active": "boolean"
+}
+```
+
+### PlayerAchievement
+```json
+{
+  "id": "string (uuid)",
+  "player_id": "string (uuid)",
+  "achievement_id": "string (uuid)",
+  "progress": "integer",
+  "is_completed": "boolean",
+  "earned_at": "string (date-time)"
+}
+```
+
+## ❌ Fehlerbehandlung
+
+### Standard-Fehlerantwort
+```json
+{
+  "success": false,
+  "message": "Fehlermeldung",
+  "error": "DETAILED_ERROR_INFO"
+}
+```
+
+### HTTP-Status-Codes
+
+- **200 OK** - Erfolgreiche Anfrage
+- **201 Created** - Ressource erfolgreich erstellt
+- **400 Bad Request** - Ungültige Anfrage
+- **401 Unauthorized** - Nicht authentifiziert
+- **403 Forbidden** - Keine Berechtigung
+- **404 Not Found** - Ressource nicht gefunden
+- **500 Internal Server Error** - Serverfehler
+
+### Häufige Fehlermeldungen
+
+- `"API-Key erforderlich"` - Fehlender oder ungültiger API-Key
+- `"Ungültige Anmeldedaten"` - Falsche Login-Daten
+- `"Ressource nicht gefunden"` - Angeforderte Ressource existiert nicht
+- `"Ungültige Daten"` - Validierungsfehler bei Eingabedaten
+- `"Keine Berechtigung"` - Unzureichende Rechte für die Aktion
+
+## 🔧 Entwicklung
+
+### Lokale Entwicklung
+```bash
+# Server starten
+npm run dev
+
+# API-Dokumentation anzeigen
+# Swagger UI verfügbar unter: http://localhost:3000/api-docs
+```
+
+### Produktionsumgebung
+```bash
+# Server starten
+npm start
+
+# API-Dokumentation: https://ninja.reptilfpv.de/api-docs
+```
+
+---
+
+**Version:** 1.0.0  
+**Base URL:** `https://ninja.reptilfpv.de/api`  
+**Autor:** Carsten Graf
diff --git a/wiki/Achievement-System.md b/wiki/Achievement-System.md
new file mode 100644
index 0000000..8acedd9
--- /dev/null
+++ b/wiki/Achievement-System.md
@@ -0,0 +1,479 @@
+# 🏆 Achievement System
+
+Umfassende Dokumentation des Achievement-Systems für das Ninja Cross Parkour System.
+
+## 📊 System-Übersicht
+
+Das Achievement-System besteht aus:
+- **32 verschiedene Achievements** in 4 Kategorien
+- **Automatische tägliche Vergabe** am Ende des Tages
+- **REST API Endpoints** für Frontend-Integration
+- **PostgreSQL Funktionen** für effiziente Verarbeitung
+
+## 🎯 Achievement-Kategorien
+
+### 1. Konsistenz-basierte Achievements
+- **Erste Schritte** 👶 - Erste Zeit aufgezeichnet (5 Punkte)
+- **Durchhalter** 💪 - 3 Versuche an einem Tag (10 Punkte)
+- **Fleißig** 🔥 - 5 Versuche an einem Tag (15 Punkte)
+- **Besessen** 😤 - 10 Versuche an einem Tag (25 Punkte)
+- **Regelmäßig** 📅 - 5 verschiedene Tage gespielt (20 Punkte)
+- **Stammgast** ⭐ - 10 verschiedene Tage gespielt (30 Punkte)
+- **Treue** 💎 - 20 verschiedene Tage gespielt (50 Punkte)
+- **Veteran** 🏆 - 50 verschiedene Tage gespielt (100 Punkte)
+
+### 2. Verbesserungs-basierte Achievements
+- **Fortschritt** 📈 - Persönliche Bestzeit um 5 Sekunden verbessert (15 Punkte)
+- **Durchbruch** ⚡ - Persönliche Bestzeit um 10 Sekunden verbessert (25 Punkte)
+- **Transformation** 🔄 - Persönliche Bestzeit um 15 Sekunden verbessert (40 Punkte)
+- **Perfektionist** ✨ - Persönliche Bestzeit um 20 Sekunden verbessert (60 Punkte)
+
+### 3. Saisonale Achievements
+- **Wochenend-Krieger** 🏁 - Am Wochenende gespielt (10 Punkte)
+- **Nachmittags-Sportler** ☀️ - Zwischen 14-18 Uhr gespielt (10 Punkte)
+- **Frühaufsteher** 🌅 - Vor 10 Uhr gespielt (15 Punkte)
+- **Abend-Sportler** 🌙 - Nach 18 Uhr gespielt (10 Punkte)
+
+### 4. Monatliche Achievements
+- **Januar-Krieger** ❄️ bis **Dezember-Dynamo** 🎄 (je 20 Punkte)
+
+### 5. Jahreszeiten-Achievements
+- **Frühjahrs-Fighter** 🌱 - Im Frühling gespielt (30 Punkte)
+- **Sommer-Sportler** ☀️ - Im Sommer gespielt (30 Punkte)
+- **Herbst-Held** 🍂 - Im Herbst gespielt (30 Punkte)
+- **Winter-Warrior** ❄️ - Im Winter gespielt (30 Punkte)
+
+## 🗄️ Datenbank-Schema
+
+### Tabelle: `achievements`
+```sql
+- id (uuid, PK)
+- name (varchar) - Achievement-Name
+- description (text) - Beschreibung
+- category (varchar) - Kategorie
+- condition_type (varchar) - Bedingungstyp
+- condition_value (integer) - Bedingungswert
+- icon (varchar) - Emoji-Icon
+- points (integer) - Punkte
+- is_active (boolean) - Aktiv
+- created_at (timestamp)
+```
+
+### Tabelle: `player_achievements`
+```sql
+- id (uuid, PK)
+- player_id (uuid, FK) - Verweis auf players.id
+- achievement_id (uuid, FK) - Verweis auf achievements.id
+- earned_at (timestamp) - Wann erreicht
+- progress (integer) - Fortschritt
+- is_completed (boolean) - Abgeschlossen
+- created_at (timestamp)
+```
+
+## 🔧 PostgreSQL Funktionen
+
+### `check_consistency_achievements(player_uuid)`
+Überprüft alle Konsistenz-basierten Achievements für einen Spieler.
+
+**Logik:**
+- Zählt Gesamtläufe des Spielers
+- Zählt Läufe pro Tag
+- Zählt verschiedene Spieltage
+- Vergibt entsprechende Achievements
+
+### `check_improvement_achievements(player_uuid)`
+Überprüft alle Verbesserungs-basierten Achievements für einen Spieler.
+
+**Logik:**
+- Ermittelt persönliche Bestzeit
+- Berechnet Verbesserung seit erster Zeit
+- Vergibt entsprechende Achievements
+
+### `check_seasonal_achievements(player_uuid)`
+Überprüft alle saisonalen und monatlichen Achievements für einen Spieler.
+
+**Logik:**
+- Prüft Wochentag (Wochenende)
+- Prüft Tageszeit (morgens, nachmittags, abends)
+- Prüft Monat (Januar bis Dezember)
+- Prüft Jahreszeit (Frühling, Sommer, Herbst, Winter)
+
+### `check_all_achievements(player_uuid)`
+Führt alle Achievement-Überprüfungen für einen Spieler aus.
+
+## 🚀 API Endpoints
+
+### GET `/api/achievements`
+Alle verfügbaren Achievements abrufen.
+
+**Response:**
+```json
+{
+  "success": true,
+  "data": [
+    {
+      "id": "uuid",
+      "name": "Erste Schritte",
+      "description": "Absolviere deinen ersten Lauf",
+      "category": "consistency",
+      "condition_type": "runs_count",
+      "condition_value": 1,
+      "icon": "👶",
+      "points": 5,
+      "is_active": true
+    }
+  ]
+}
+```
+
+### GET `/api/achievements/player/:playerId`
+Achievements eines bestimmten Spielers abrufen.
+
+**Response:**
+```json
+{
+  "success": true,
+  "data": [
+    {
+      "id": "uuid",
+      "achievement_id": "uuid",
+      "name": "Erste Schritte",
+      "description": "Absolviere deinen ersten Lauf",
+      "icon": "👶",
+      "points": 5,
+      "progress": 1,
+      "is_completed": true,
+      "earned_at": "2024-01-01T00:00:00Z"
+    }
+  ]
+}
+```
+
+### GET `/api/achievements/player/:playerId/stats`
+Achievement-Statistiken eines Spielers abrufen.
+
+**Response:**
+```json
+{
+  "success": true,
+  "data": {
+    "total_achievements": 32,
+    "completed_achievements": 5,
+    "total_points": 150,
+    "earned_points": 75,
+    "completion_percentage": 15.6
+  }
+}
+```
+
+### POST `/api/achievements/check/:playerId`
+Achievements für einen Spieler manuell überprüfen.
+
+**Request:**
+```json
+{
+  "achievement_id": "uuid"
+}
+```
+
+### POST `/api/achievements/daily-check`
+Tägliche Achievement-Überprüfung für alle Spieler ausführen.
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Daily achievement check completed",
+  "players_checked": 150,
+  "achievements_awarded": 25
+}
+```
+
+### GET `/api/achievements/leaderboard?limit=10`
+Bestenliste der Spieler nach Achievement-Punkten.
+
+**Response:**
+```json
+{
+  "success": true,
+  "data": [
+    {
+      "player_id": "uuid",
+      "firstname": "Max",
+      "lastname": "Mustermann",
+      "total_points": 500,
+      "completed_achievements": 15,
+      "rank": 1
+    }
+  ]
+}
+```
+
+## 📅 Automatisierung
+
+### Tägliches Script
+```bash
+# Manuell ausführen
+node scripts/daily_achievements.js
+
+# Cron-Job einrichten
+node scripts/setup_cron.js setup
+
+# Cron-Job Status prüfen
+node scripts/setup_cron.js status
+
+# Cron-Job entfernen
+node scripts/setup_cron.js remove
+```
+
+### Cron-Schedule
+- **Zeit**: Täglich um 23:59 Uhr
+- **Log**: `/var/log/ninjaserver_achievements.log`
+
+### Script-Details
+```javascript
+// scripts/daily_achievements.js
+const { checkAllAchievements } = require('../models/Achievement');
+
+async function dailyCheck() {
+  try {
+    // Alle Spieler abrufen
+    const players = await getAllPlayers();
+    
+    let totalAwarded = 0;
+    
+    for (const player of players) {
+      const awarded = await checkAllAchievements(player.id);
+      totalAwarded += awarded;
+    }
+    
+    console.log(`Daily check completed: ${totalAwarded} achievements awarded`);
+  } catch (error) {
+    console.error('Daily check failed:', error);
+  }
+}
+```
+
+## 🎮 Frontend-Integration
+
+### Beispiel: Achievement-Liste laden
+```javascript
+async function loadAchievements(playerId) {
+  try {
+    const response = await fetch(`/api/achievements/player/${playerId}`);
+    const data = await response.json();
+    
+    if (data.success) {
+      data.data.forEach(achievement => {
+        const status = achievement.is_completed ? '✅' : '❌';
+        console.log(`${achievement.icon} ${achievement.name}: ${status}`);
+      });
+    }
+  } catch (error) {
+    console.error('Error loading achievements:', error);
+  }
+}
+```
+
+### Beispiel: Statistiken anzeigen
+```javascript
+async function loadStats(playerId) {
+  try {
+    const response = await fetch(`/api/achievements/player/${playerId}/stats`);
+    const data = await response.json();
+    
+    if (data.success) {
+      const stats = data.data;
+      document.getElementById('total-points').textContent = stats.total_points;
+      document.getElementById('completed').textContent = 
+        `${stats.completed_achievements}/${stats.total_achievements}`;
+      document.getElementById('percentage').textContent = 
+        `${stats.completion_percentage}%`;
+    }
+  } catch (error) {
+    console.error('Error loading stats:', error);
+  }
+}
+```
+
+### Beispiel: Achievement-Animation
+```javascript
+function showAchievementNotification(achievement) {
+  const notification = document.createElement('div');
+  notification.className = 'achievement-notification';
+  notification.innerHTML = `
+    <div class="achievement-icon">${achievement.icon}</div>
+    <div class="achievement-text">
+      <h3>${achievement.name}</h3>
+      <p>${achievement.description}</p>
+      <span class="points">+${achievement.points} Punkte</span>
+    </div>
+  `;
+  
+  document.body.appendChild(notification);
+  
+  // Animation
+  setTimeout(() => {
+    notification.classList.add('show');
+  }, 100);
+  
+  // Entfernen nach 5 Sekunden
+  setTimeout(() => {
+    notification.remove();
+  }, 5000);
+}
+```
+
+## 🔍 Monitoring
+
+### Logs überwachen
+```bash
+# Live-Logs anzeigen
+tail -f /var/log/ninjaserver_achievements.log
+
+# Letzte Ausführung prüfen
+grep "Daily achievement check completed" /var/log/ninjaserver_achievements.log | tail -1
+
+# Fehler-Logs anzeigen
+grep "ERROR" /var/log/ninjaserver_achievements.log
+```
+
+### Datenbank-Status prüfen
+```sql
+-- Achievement-Statistiken
+SELECT 
+    COUNT(*) as total_achievements,
+    COUNT(CASE WHEN is_active = true THEN 1 END) as active_achievements
+FROM achievements;
+
+-- Spieler-Statistiken
+SELECT 
+    COUNT(DISTINCT player_id) as players_with_achievements,
+    COUNT(*) as total_earned_achievements
+FROM player_achievements 
+WHERE is_completed = true;
+
+-- Top-Spieler
+SELECT 
+    p.firstname,
+    p.lastname,
+    COUNT(pa.id) as achievements,
+    SUM(a.points) as total_points
+FROM players p
+JOIN player_achievements pa ON p.id = pa.player_id
+JOIN achievements a ON pa.achievement_id = a.id
+WHERE pa.is_completed = true
+GROUP BY p.id, p.firstname, p.lastname
+ORDER BY total_points DESC
+LIMIT 10;
+```
+
+## 🛠️ Wartung
+
+### Neue Achievements hinzufügen
+1. Achievement in `achievements` Tabelle einfügen:
+```sql
+INSERT INTO achievements (name, description, category, condition_type, condition_value, icon, points)
+VALUES ('Neues Achievement', 'Beschreibung', 'consistency', 'runs_count', 5, '🏆', 25);
+```
+
+2. Logik in entsprechenden PostgreSQL Funktionen erweitern
+3. API Endpoints testen
+
+### Achievement deaktivieren
+```sql
+UPDATE achievements SET is_active = false WHERE name = 'Achievement-Name';
+```
+
+### Daten zurücksetzen
+```sql
+-- Alle Spieler-Achievements löschen
+DELETE FROM player_achievements;
+
+-- Achievement-Statistiken zurücksetzen
+UPDATE achievements SET created_at = NOW();
+```
+
+### Achievement-Import/Export
+```bash
+# Export
+pg_dump -t achievements -t player_achievements ninjaserver > achievements_backup.sql
+
+# Import
+psql ninjaserver < achievements_backup.sql
+```
+
+## 📈 Performance
+
+### Indizierung
+```sql
+-- Performance-Indizes
+CREATE INDEX CONCURRENTLY idx_player_achievements_player_id 
+ON player_achievements(player_id);
+
+CREATE INDEX CONCURRENTLY idx_player_achievements_achievement_id 
+ON player_achievements(achievement_id);
+
+CREATE INDEX CONCURRENTLY idx_player_achievements_completed 
+ON player_achievements(is_completed) WHERE is_completed = true;
+```
+
+### Batch-Processing
+- **Effiziente Verarbeitung** aller Spieler in einem Durchgang
+- **Transaktionale Sicherheit** für Datenkonsistenz
+- **Fehlerbehandlung** für einzelne Spieler
+
+### Caching
+- **Achievement-Definitionen** werden gecacht
+- **Spieler-Statistiken** werden bei Änderungen neu berechnet
+- **Leaderboard** wird periodisch aktualisiert
+
+### Zeitzone-Behandlung
+- **Korrekte Zeitzone** (Europe/Berlin) für alle Zeitberechnungen
+- **Saisonale Achievements** berücksichtigen lokale Zeit
+- **Tägliche Prüfung** erfolgt zur richtigen Zeit
+
+## 🔒 Sicherheit
+
+### API-Schutz
+- **Alle Endpoints** über bestehende Authentifizierung
+- **Admin-Endpoints** erfordern erweiterte Berechtigung
+- **Rate Limiting** für häufige Anfragen
+
+### SQL-Injection
+- **Parametrisierte Queries** in allen Funktionen
+- **Input-Validierung** vor Datenbankzugriff
+- **Escape-Funktionen** für dynamische Inhalte
+
+### Datenvalidierung
+- **Eingabe-Validierung** in allen API-Endpoints
+- **Typ-Überprüfung** für alle Parameter
+- **Bereichs-Validierung** für numerische Werte
+
+### Fehlerbehandlung
+- **Umfassende Error-Handling** in allen Funktionen
+- **Logging** aller Fehler und Warnungen
+- **Graceful Degradation** bei Systemfehlern
+
+## 🎯 Best Practices
+
+### Achievement-Design
+- **Klare Bedingungen** für alle Achievements
+- **Angemessene Punkte** basierend auf Schwierigkeit
+- **Motivierende Beschreibungen** für Spieler
+
+### Performance-Optimierung
+- **Batch-Processing** für große Datenmengen
+- **Indizierung** für häufige Abfragen
+- **Caching** für statische Daten
+
+### Wartbarkeit
+- **Modulare Struktur** für einfache Erweiterungen
+- **Dokumentation** aller Funktionen
+- **Tests** für kritische Komponenten
+
+---
+
+**Erstellt am**: $(date)  
+**Version**: 1.0.0  
+**Autor**: Ninja Cross Parkour System
diff --git a/wiki/Benutzerhandbuch.md b/wiki/Benutzerhandbuch.md
new file mode 100644
index 0000000..959e79d
--- /dev/null
+++ b/wiki/Benutzerhandbuch.md
@@ -0,0 +1,261 @@
+# 📖 Benutzerhandbuch
+
+Anleitung für Endbenutzer des Ninja Cross Parkour Systems.
+
+## 🎯 Übersicht
+
+Das Ninja Cross Parkour System ermöglicht es Schwimmbadbesuchern, ihre Parkour-Zeiten zu messen, zu verfolgen und sich mit anderen zu vergleichen.
+
+## 🚀 Erste Schritte
+
+### 1. Registrierung
+1. Öffnen Sie das Web-Interface
+2. Klicken Sie auf "Registrieren"
+3. Füllen Sie das Formular aus:
+   - Vorname
+   - Nachname
+   - Geburtsdatum
+   - RFID-Karten-ID (falls vorhanden)
+
+### 2. RFID-Karte verknüpfen
+Falls Sie eine RFID-Karte haben:
+1. Melden Sie sich an
+2. Gehen Sie zu "Mein Profil"
+3. Klicken Sie auf "RFID-Karte verknüpfen"
+4. Halten Sie Ihre Karte an den Reader
+
+### 3. Erste Zeit messen
+1. Wählen Sie einen Standort aus
+2. Halten Sie Ihre RFID-Karte an den Start-Reader
+3. Laufen Sie den Parkour
+4. Halten Sie Ihre Karte an den Ziel-Reader
+5. Ihre Zeit wird automatisch aufgezeichnet
+
+## 🏠 Dashboard
+
+### Übersicht
+Das Dashboard zeigt:
+- **Aktuelle Zeit** - Ihre letzte gemessene Zeit
+- **Beste Zeit** - Ihr persönlicher Rekord
+- **Achievements** - Ihre Erfolge
+- **Statistiken** - Fortschritt und Trends
+
+### Navigation
+- **🏠 Home** - Dashboard und Übersicht
+- **⏱️ Zeiten** - Alle Ihre gemessenen Zeiten
+- **🏆 Achievements** - Erfolge und Fortschritt
+- **📊 Statistiken** - Detaillierte Analysen
+- **👤 Profil** - Persönliche Einstellungen
+
+## ⏱️ Zeitmessung
+
+### Wie funktioniert es?
+1. **Start:** RFID-Karte an Start-Reader halten
+2. **Parkour:** Den Parcours absolvieren
+3. **Ziel:** RFID-Karte an Ziel-Reader halten
+4. **Ergebnis:** Zeit wird automatisch berechnet und gespeichert
+
+### Zeitformat
+Zeiten werden im Format `MM:SS.mmm` angezeigt:
+- **Minuten:SSekunden.Millisekunden**
+- Beispiel: `01:23.456` = 1 Minute, 23 Sekunden, 456 Millisekunden
+
+### Gültige Zeiten
+- **Minimum:** 30 Sekunden
+- **Maximum:** 10 Minuten
+- **Schwelle:** Konfigurierbar pro Standort
+
+## 🏆 Achievement System
+
+### Was sind Achievements?
+Achievements sind Erfolge, die Sie durch verschiedene Aktivitäten freischalten können.
+
+### Kategorien
+
+#### 🎯 Konsistenz-basierte Achievements
+- **Erste Schritte** 👶 - Erste Zeit aufgezeichnet (5 Punkte)
+- **Durchhalter** 💪 - 3 Versuche an einem Tag (10 Punkte)
+- **Fleißig** 🔥 - 5 Versuche an einem Tag (15 Punkte)
+- **Besessen** 😤 - 10 Versuche an einem Tag (25 Punkte)
+- **Regelmäßig** 📅 - 5 verschiedene Tage gespielt (20 Punkte)
+- **Stammgast** ⭐ - 10 verschiedene Tage gespielt (30 Punkte)
+- **Treue** 💎 - 20 verschiedene Tage gespielt (50 Punkte)
+- **Veteran** 🏆 - 50 verschiedene Tage gespielt (100 Punkte)
+
+#### 📈 Verbesserungs-basierte Achievements
+- **Fortschritt** 📈 - Persönliche Bestzeit um 5 Sekunden verbessert (15 Punkte)
+- **Durchbruch** ⚡ - Persönliche Bestzeit um 10 Sekunden verbessert (25 Punkte)
+- **Transformation** 🔄 - Persönliche Bestzeit um 15 Sekunden verbessert (40 Punkte)
+- **Perfektionist** ✨ - Persönliche Bestzeit um 20 Sekunden verbessert (60 Punkte)
+
+#### 🌍 Saisonale Achievements
+- **Wochenend-Krieger** 🏁 - Am Wochenende gespielt (10 Punkte)
+- **Nachmittags-Sportler** ☀️ - Zwischen 14-18 Uhr gespielt (10 Punkte)
+- **Frühaufsteher** 🌅 - Vor 10 Uhr gespielt (15 Punkte)
+- **Abend-Sportler** 🌙 - Nach 18 Uhr gespielt (10 Punkte)
+
+#### 📅 Monatliche Achievements
+- **Januar-Krieger** ❄️ bis **Dezember-Dynamo** 🎄 (je 20 Punkte)
+
+#### 🌸 Jahreszeiten-Achievements
+- **Frühjahrs-Fighter** 🌱 - Im Frühling gespielt (30 Punkte)
+- **Sommer-Sportler** ☀️ - Im Sommer gespielt (30 Punkte)
+- **Herbst-Held** 🍂 - Im Herbst gespielt (30 Punkte)
+- **Winter-Warrior** ❄️ - Im Winter gespielt (30 Punkte)
+
+### Achievement-Status
+- **✅ Abgeschlossen** - Achievement erreicht
+- **🔄 In Bearbeitung** - Fortschritt wird gemacht
+- **❌ Nicht freigeschaltet** - Noch nicht begonnen
+
+## 📊 Statistiken
+
+### Persönliche Statistiken
+- **Gesamtzeiten** - Anzahl aller gemessenen Zeiten
+- **Beste Zeit** - Schnellste gemessene Zeit
+- **Durchschnittszeit** - Durchschnittliche Zeit
+- **Verbesserung** - Zeitverbesserung seit dem ersten Lauf
+- **Aktivitätstage** - Anzahl der Tage mit Aktivität
+
+### Fortschritts-Tracking
+- **Wöchentlicher Fortschritt** - Zeiten der letzten 7 Tage
+- **Monatlicher Fortschritt** - Zeiten des aktuellen Monats
+- **Jährlicher Fortschritt** - Zeiten des aktuellen Jahres
+
+### Vergleiche
+- **Persönliche Bestenliste** - Ihre eigenen Top-Zeiten
+- **Standort-Vergleich** - Zeiten an verschiedenen Standorten
+- **Zeitverlauf** - Entwicklung Ihrer Zeiten über die Zeit
+
+## 🗺️ Standorte
+
+### Verfügbare Standorte
+Das System unterstützt mehrere Standorte:
+- **Hauptstandort** - Hauptparkour
+- **Training** - Übungsbereich
+- **Wettkampf** - Wettkampfbereich
+
+### Standort-Informationen
+Jeder Standort zeigt:
+- **Name** - Standortbezeichnung
+- **Schwelle** - Mindestzeit für gültige Zeiten
+- **Beste Zeit** - Rekordzeit an diesem Standort
+- **Karte** - Geografische Position
+
+## 🔔 Benachrichtigungen
+
+### Push-Benachrichtigungen
+Aktivieren Sie Push-Benachrichtigungen für:
+- **Neue Rekorde** - Persönliche Bestzeiten
+- **Achievements** - Neue Erfolge
+- **System-Updates** - Wichtige Ankündigungen
+
+### E-Mail-Benachrichtigungen
+Konfigurieren Sie E-Mail-Benachrichtigungen für:
+- **Wöchentliche Zusammenfassung** - Ihre Aktivitäten
+- **Monatliche Statistiken** - Detaillierte Berichte
+- **System-Updates** - Wichtige Änderungen
+
+## 👤 Profil verwalten
+
+### Persönliche Daten
+- **Name** - Vor- und Nachname
+- **Geburtsdatum** - Für Alterskategorien
+- **E-Mail** - Für Benachrichtigungen
+- **RFID-Karte** - Verknüpfte Karten
+
+### Einstellungen
+- **Zeitzone** - Für korrekte Zeitstempel
+- **Sprache** - Interface-Sprache
+- **Benachrichtigungen** - Push und E-Mail Einstellungen
+- **Datenschutz** - Sichtbarkeit Ihrer Daten
+
+### Datenschutz
+- **Öffentliche Profile** - Sichtbar für andere Benutzer
+- **Private Profile** - Nur für Sie sichtbar
+- **Datenexport** - Ihre Daten herunterladen
+- **Konto löschen** - Alle Daten entfernen
+
+## 🏅 Bestenlisten
+
+### Globale Bestenlisten
+- **Schnellste Zeiten** - Alle Zeiten aller Benutzer
+- **Meiste Achievements** - Benutzer mit den meisten Erfolgen
+- **Aktivste Spieler** - Benutzer mit den meisten Läufen
+
+### Kategorien
+- **Gesamt** - Alle Altersgruppen
+- **Jugend** - Unter 18 Jahren
+- **Erwachsene** - 18-65 Jahre
+- **Senioren** - Über 65 Jahre
+
+### Zeiträume
+- **Heute** - Beste Zeiten des Tages
+- **Diese Woche** - Beste Zeiten der Woche
+- **Dieser Monat** - Beste Zeiten des Monats
+- **Dieses Jahr** - Beste Zeiten des Jahres
+- **Alle Zeiten** - Historische Bestenliste
+
+## 🔧 Troubleshooting
+
+### Häufige Probleme
+
+#### RFID-Karte wird nicht erkannt
+1. Karte richtig positionieren
+2. Reader auf Verschmutzung prüfen
+3. Karte auf Beschädigungen prüfen
+4. Administrator kontaktieren
+
+#### Zeit wird nicht gespeichert
+1. Gültige Zeit prüfen (innerhalb der Schwelle)
+2. Standort korrekt ausgewählt
+3. Internetverbindung prüfen
+4. Seite neu laden
+
+#### Achievements werden nicht vergeben
+1. Tägliche Prüfung abwarten
+2. Bedingungen erfüllt prüfen
+3. System-Status prüfen
+4. Administrator kontaktieren
+
+### Support kontaktieren
+- **E-Mail** - support@ninjaparkour.de
+- **Telefon** - +49 (0) 123 456 789
+- **Chat** - Verfügbar im Web-Interface
+
+## 📱 Mobile Nutzung
+
+### Responsive Design
+Das System ist für alle Geräte optimiert:
+- **Desktop** - Vollständige Funktionalität
+- **Tablet** - Touch-optimierte Bedienung
+- **Smartphone** - Kompakte Ansicht
+
+### Mobile App (geplant)
+- **Native App** - Für iOS und Android
+- **Offline-Modus** - Zeiten ohne Internet
+- **Push-Benachrichtigungen** - Sofortige Updates
+
+## 🎓 Tipps und Tricks
+
+### Bessere Zeiten erzielen
+1. **Regelmäßig trainieren** - Konsistenz ist wichtig
+2. **Technik verbessern** - Effiziente Bewegungen
+3. **Kondition aufbauen** - Ausdauer trainieren
+4. **Mental vorbereiten** - Konzentration und Fokus
+
+### Achievements sammeln
+1. **Verschiedene Zeiten** - Morgens, mittags, abends
+2. **Wochenenden** - Zusätzliche Aktivität
+3. **Konsistent bleiben** - Regelmäßige Teilnahme
+4. **Verbesserungen** - Persönliche Bestzeiten brechen
+
+### System optimal nutzen
+1. **Profil vollständig** - Alle Daten ausfüllen
+2. **Benachrichtigungen aktivieren** - Updates erhalten
+3. **Statistiken verfolgen** - Fortschritt beobachten
+4. **Community nutzen** - Mit anderen vergleichen
+
+---
+
+**Hinweis:** Bei technischen Problemen wenden Sie sich an den Systemadministrator oder konsultieren Sie die [Troubleshooting](Troubleshooting)-Seite.
diff --git a/wiki/Datenbank.md b/wiki/Datenbank.md
new file mode 100644
index 0000000..494edc6
--- /dev/null
+++ b/wiki/Datenbank.md
@@ -0,0 +1,588 @@
+# 🗄️ Datenbank
+
+Dokumentation der PostgreSQL-Datenbank des Ninja Cross Parkour Systems.
+
+## 📋 Inhaltsverzeichnis
+
+- [🏗️ Schema-Übersicht](#️-schema-übersicht)
+- [📊 Tabellen](#-tabellen)
+- [🔗 Beziehungen](#-beziehungen)
+- [📈 Indizes](#-indizes)
+- [🔧 Funktionen](#-funktionen)
+- [📊 Statistiken](#-statistiken)
+- [🛠️ Wartung](#️-wartung)
+
+## 🏗️ Schema-Übersicht
+
+### Datenbank-Name
+`ninjaserver`
+
+### Zeichensatz
+`UTF-8`
+
+### Zeitzone
+`Europe/Berlin`
+
+### Version
+PostgreSQL 12 oder höher
+
+## 📊 Tabellen
+
+### `players` - Spieler
+```sql
+CREATE TABLE players (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    firstname VARCHAR(50) NOT NULL,
+    lastname VARCHAR(50) NOT NULL,
+    birthdate DATE NOT NULL,
+    rfiduid VARCHAR(20) UNIQUE,
+    supabase_user_id UUID,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+**Beschreibung:** Speichert alle Spieler-Informationen.
+
+**Felder:**
+- `id` - Eindeutige UUID
+- `firstname` - Vorname (max. 50 Zeichen)
+- `lastname` - Nachname (max. 50 Zeichen)
+- `birthdate` - Geburtsdatum
+- `rfiduid` - RFID-Karten-ID (eindeutig)
+- `supabase_user_id` - Verknüpfung zu Supabase
+- `created_at` - Erstellungszeitpunkt
+- `updated_at` - Letzte Aktualisierung
+
+### `locations` - Standorte
+```sql
+CREATE TABLE locations (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name VARCHAR(255) UNIQUE NOT NULL,
+    latitude DECIMAL(10, 8) NOT NULL,
+    longitude DECIMAL(11, 8) NOT NULL,
+    time_threshold JSONB DEFAULT '{"seconds": 120}',
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+**Beschreibung:** Speichert alle Parkour-Standorte.
+
+**Felder:**
+- `id` - Eindeutige UUID
+- `name` - Standortname (eindeutig)
+- `latitude` - Breitengrad (10,8 Dezimalstellen)
+- `longitude` - Längengrad (11,8 Dezimalstellen)
+- `time_threshold` - Zeit-Schwelle als JSON
+- `created_at` - Erstellungszeitpunkt
+- `updated_at` - Letzte Aktualisierung
+
+### `times` - Zeiten
+```sql
+CREATE TABLE times (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    player_id UUID REFERENCES players(id) ON DELETE CASCADE,
+    location_id UUID REFERENCES locations(id) ON DELETE CASCADE,
+    recorded_time JSONB NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+**Beschreibung:** Speichert alle gemessenen Zeiten.
+
+**Felder:**
+- `id` - Eindeutige UUID
+- `player_id` - Verweis auf Spieler
+- `location_id` - Verweis auf Standort
+- `recorded_time` - Zeit als JSON (Sekunden, Minuten, Millisekunden)
+- `created_at` - Erstellungszeitpunkt
+
+### `achievements` - Achievements
+```sql
+CREATE TABLE achievements (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name VARCHAR(255) NOT NULL,
+    description TEXT,
+    category VARCHAR(50) NOT NULL,
+    condition_type VARCHAR(50) NOT NULL,
+    condition_value INTEGER NOT NULL,
+    icon VARCHAR(10),
+    points INTEGER DEFAULT 0,
+    is_active BOOLEAN DEFAULT true,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+**Beschreibung:** Definiert alle verfügbaren Achievements.
+
+**Felder:**
+- `id` - Eindeutige UUID
+- `name` - Achievement-Name
+- `description` - Beschreibung
+- `category` - Kategorie (consistency, improvement, seasonal, monthly)
+- `condition_type` - Bedingungstyp
+- `condition_value` - Bedingungswert
+- `icon` - Emoji-Icon
+- `points` - Punkte
+- `is_active` - Aktiv-Status
+- `created_at` - Erstellungszeitpunkt
+- `updated_at` - Letzte Aktualisierung
+
+### `player_achievements` - Spieler-Achievements
+```sql
+CREATE TABLE player_achievements (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    player_id UUID REFERENCES players(id) ON DELETE CASCADE,
+    achievement_id UUID REFERENCES achievements(id) ON DELETE CASCADE,
+    earned_at TIMESTAMP,
+    progress INTEGER DEFAULT 0,
+    is_completed BOOLEAN DEFAULT false,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(player_id, achievement_id)
+);
+```
+
+**Beschreibung:** Verknüpft Spieler mit ihren Achievements.
+
+**Felder:**
+- `id` - Eindeutige UUID
+- `player_id` - Verweis auf Spieler
+- `achievement_id` - Verweis auf Achievement
+- `earned_at` - Zeitpunkt der Verleihung
+- `progress` - Fortschritt (0-100)
+- `is_completed` - Abgeschlossen-Status
+- `created_at` - Erstellungszeitpunkt
+
+### `adminusers` - Admin-Benutzer
+```sql
+CREATE TABLE adminusers (
+    id SERIAL PRIMARY KEY,
+    username VARCHAR(50) UNIQUE NOT NULL,
+    password_hash VARCHAR(255) NOT NULL,
+    is_active BOOLEAN DEFAULT true,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    last_login TIMESTAMP
+);
+```
+
+**Beschreibung:** Speichert Admin-Benutzer für das System.
+
+**Felder:**
+- `id` - Auto-increment ID
+- `username` - Benutzername (eindeutig)
+- `password_hash` - Gehashtes Passwort
+- `is_active` - Aktiv-Status
+- `created_at` - Erstellungszeitpunkt
+- `last_login` - Letzter Login
+
+### `api_tokens` - API-Tokens
+```sql
+CREATE TABLE api_tokens (
+    id SERIAL PRIMARY KEY,
+    token VARCHAR(255) UNIQUE NOT NULL,
+    description TEXT,
+    standorte TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    expires_at TIMESTAMP,
+    is_active BOOLEAN DEFAULT true
+);
+```
+
+**Beschreibung:** Speichert API-Tokens für Authentifizierung.
+
+**Felder:**
+- `id` - Auto-increment ID
+- `token` - API-Token (eindeutig)
+- `description` - Beschreibung
+- `standorte` - Zugewiesene Standorte
+- `created_at` - Erstellungszeitpunkt
+- `expires_at` - Ablaufzeitpunkt
+- `is_active` - Aktiv-Status
+
+### `page_views` - Seitenaufrufe
+```sql
+CREATE TABLE page_views (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    page VARCHAR(255) NOT NULL,
+    user_agent TEXT,
+    ip_address INET,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+**Beschreibung:** Verfolgt Seitenaufrufe für Statistiken.
+
+**Felder:**
+- `id` - Eindeutige UUID
+- `page` - Seitenname
+- `user_agent` - Browser-Informationen
+- `ip_address` - IP-Adresse
+- `created_at` - Zeitpunkt des Aufrufs
+
+## 🔗 Beziehungen
+
+### Foreign Key Constraints
+```sql
+-- times -> players
+ALTER TABLE times 
+ADD CONSTRAINT fk_times_player 
+FOREIGN KEY (player_id) REFERENCES players(id) ON DELETE CASCADE;
+
+-- times -> locations
+ALTER TABLE times 
+ADD CONSTRAINT fk_times_location 
+FOREIGN KEY (location_id) REFERENCES locations(id) ON DELETE CASCADE;
+
+-- player_achievements -> players
+ALTER TABLE player_achievements 
+ADD CONSTRAINT fk_player_achievements_player 
+FOREIGN KEY (player_id) REFERENCES players(id) ON DELETE CASCADE;
+
+-- player_achievements -> achievements
+ALTER TABLE player_achievements 
+ADD CONSTRAINT fk_player_achievements_achievement 
+FOREIGN KEY (achievement_id) REFERENCES achievements(id) ON DELETE CASCADE;
+```
+
+### Beziehungsdiagramm
+```
+players (1) -----> (N) times
+players (1) -----> (N) player_achievements
+locations (1) ---> (N) times
+achievements (1) -> (N) player_achievements
+```
+
+## 📈 Indizes
+
+### Primäre Indizes
+```sql
+-- Primärschlüssel (automatisch)
+CREATE UNIQUE INDEX idx_players_pkey ON players(id);
+CREATE UNIQUE INDEX idx_locations_pkey ON locations(id);
+CREATE UNIQUE INDEX idx_times_pkey ON times(id);
+CREATE UNIQUE INDEX idx_achievements_pkey ON achievements(id);
+CREATE UNIQUE INDEX idx_player_achievements_pkey ON player_achievements(id);
+```
+
+### Performance-Indizes
+```sql
+-- Zeiten-Indizes
+CREATE INDEX idx_times_player_id ON times(player_id);
+CREATE INDEX idx_times_location_id ON times(location_id);
+CREATE INDEX idx_times_created_at ON times(created_at);
+CREATE INDEX idx_times_player_created ON times(player_id, created_at DESC);
+
+-- Achievement-Indizes
+CREATE INDEX idx_player_achievements_player_id ON player_achievements(player_id);
+CREATE INDEX idx_player_achievements_achievement_id ON player_achievements(achievement_id);
+CREATE INDEX idx_player_achievements_completed ON player_achievements(is_completed) WHERE is_completed = true;
+
+-- Standort-Indizes
+CREATE INDEX idx_locations_name ON locations(name);
+CREATE INDEX idx_locations_coordinates ON locations(latitude, longitude);
+
+-- Spieler-Indizes
+CREATE INDEX idx_players_rfiduid ON players(rfiduid);
+CREATE INDEX idx_players_supabase_user_id ON players(supabase_user_id);
+CREATE INDEX idx_players_name ON players(firstname, lastname);
+
+-- API-Token-Indizes
+CREATE INDEX idx_api_tokens_token ON api_tokens(token);
+CREATE INDEX idx_api_tokens_active ON api_tokens(is_active) WHERE is_active = true;
+
+-- Seitenaufruf-Indizes
+CREATE INDEX idx_page_views_page ON page_views(page);
+CREATE INDEX idx_page_views_created_at ON page_views(created_at);
+```
+
+### Composite-Indizes
+```sql
+-- Für häufige Abfragen
+CREATE INDEX idx_times_player_location_time ON times(player_id, location_id, created_at DESC);
+CREATE INDEX idx_player_achievements_player_completed ON player_achievements(player_id, is_completed);
+CREATE INDEX idx_achievements_category_active ON achievements(category, is_active);
+```
+
+## 🔧 Funktionen
+
+### Achievement-Funktionen
+```sql
+-- Konsistenz-basierte Achievements prüfen
+CREATE OR REPLACE FUNCTION check_consistency_achievements(player_uuid UUID)
+RETURNS INTEGER AS $$
+DECLARE
+    awarded_count INTEGER := 0;
+    total_runs INTEGER;
+    runs_today INTEGER;
+    unique_days INTEGER;
+BEGIN
+    -- Gesamtläufe zählen
+    SELECT COUNT(*) INTO total_runs
+    FROM times WHERE player_id = player_uuid;
+    
+    -- Läufe heute zählen
+    SELECT COUNT(*) INTO runs_today
+    FROM times 
+    WHERE player_id = player_uuid 
+    AND DATE(created_at) = CURRENT_DATE;
+    
+    -- Verschiedene Tage zählen
+    SELECT COUNT(DISTINCT DATE(created_at)) INTO unique_days
+    FROM times WHERE player_id = player_uuid;
+    
+    -- Achievements vergeben
+    -- (Detaillierte Logik hier...)
+    
+    RETURN awarded_count;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Verbesserungs-basierte Achievements prüfen
+CREATE OR REPLACE FUNCTION check_improvement_achievements(player_uuid UUID)
+RETURNS INTEGER AS $$
+-- (Implementierung...)
+$$ LANGUAGE plpgsql;
+
+-- Saisonale Achievements prüfen
+CREATE OR REPLACE FUNCTION check_seasonal_achievements(player_uuid UUID)
+RETURNS INTEGER AS $$
+-- (Implementierung...)
+$$ LANGUAGE plpgsql;
+
+-- Alle Achievements prüfen
+CREATE OR REPLACE FUNCTION check_all_achievements(player_uuid UUID)
+RETURNS INTEGER AS $$
+DECLARE
+    total_awarded INTEGER := 0;
+BEGIN
+    total_awarded := total_awarded + check_consistency_achievements(player_uuid);
+    total_awarded := total_awarded + check_improvement_achievements(player_uuid);
+    total_awarded := total_awarded + check_seasonal_achievements(player_uuid);
+    
+    RETURN total_awarded;
+END;
+$$ LANGUAGE plpgsql;
+```
+
+### Utility-Funktionen
+```sql
+-- Beste Zeit eines Spielers ermitteln
+CREATE OR REPLACE FUNCTION get_best_time(player_uuid UUID)
+RETURNS JSONB AS $$
+DECLARE
+    best_time JSONB;
+BEGIN
+    SELECT recorded_time INTO best_time
+    FROM times
+    WHERE player_id = player_uuid
+    ORDER BY (recorded_time->>'seconds')::INTEGER ASC
+    LIMIT 1;
+    
+    RETURN COALESCE(best_time, '{"seconds": 0, "minutes": 0, "milliseconds": 0}');
+END;
+$$ LANGUAGE plpgsql;
+
+-- Spieler-Statistiken berechnen
+CREATE OR REPLACE FUNCTION get_player_stats(player_uuid UUID)
+RETURNS JSONB AS $$
+DECLARE
+    stats JSONB;
+    total_runs INTEGER;
+    best_time JSONB;
+    avg_time JSONB;
+BEGIN
+    SELECT COUNT(*) INTO total_runs FROM times WHERE player_id = player_uuid;
+    SELECT get_best_time(player_uuid) INTO best_time;
+    
+    -- Durchschnittszeit berechnen
+    SELECT jsonb_build_object(
+        'seconds', AVG((recorded_time->>'seconds')::INTEGER),
+        'minutes', AVG((recorded_time->>'minutes')::INTEGER),
+        'milliseconds', AVG((recorded_time->>'milliseconds')::INTEGER)
+    ) INTO avg_time
+    FROM times WHERE player_id = player_uuid;
+    
+    stats := jsonb_build_object(
+        'total_runs', total_runs,
+        'best_time', best_time,
+        'average_time', avg_time
+    );
+    
+    RETURN stats;
+END;
+$$ LANGUAGE plpgsql;
+```
+
+## 📊 Statistiken
+
+### Datenbank-Größe
+```sql
+-- Gesamtgröße der Datenbank
+SELECT pg_size_pretty(pg_database_size('ninjaserver')) as database_size;
+
+-- Größe der einzelnen Tabellen
+SELECT 
+    schemaname,
+    tablename,
+    pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) as size
+FROM pg_tables 
+WHERE schemaname = 'public'
+ORDER BY pg_total_relation_size(schemaname||'.'||tablename) DESC;
+```
+
+### Tabellen-Statistiken
+```sql
+-- Anzahl der Datensätze pro Tabelle
+SELECT 
+    'players' as table_name, COUNT(*) as record_count FROM players
+UNION ALL
+SELECT 'locations', COUNT(*) FROM locations
+UNION ALL
+SELECT 'times', COUNT(*) FROM times
+UNION ALL
+SELECT 'achievements', COUNT(*) FROM achievements
+UNION ALL
+SELECT 'player_achievements', COUNT(*) FROM player_achievements
+UNION ALL
+SELECT 'adminusers', COUNT(*) FROM adminusers
+UNION ALL
+SELECT 'api_tokens', COUNT(*) FROM api_tokens
+UNION ALL
+SELECT 'page_views', COUNT(*) FROM page_views;
+```
+
+### Performance-Statistiken
+```sql
+-- Langsamste Queries
+SELECT 
+    query,
+    calls,
+    total_time,
+    mean_time,
+    rows
+FROM pg_stat_statements 
+ORDER BY mean_time DESC 
+LIMIT 10;
+
+-- Index-Nutzung
+SELECT 
+    schemaname,
+    tablename,
+    indexname,
+    idx_scan,
+    idx_tup_read,
+    idx_tup_fetch
+FROM pg_stat_user_indexes 
+ORDER BY idx_scan DESC;
+```
+
+## 🛠️ Wartung
+
+### Backup
+```bash
+# Vollständiges Backup
+pg_dump -h localhost -U username -d ninjaserver > ninjaserver_backup.sql
+
+# Nur Schema
+pg_dump -h localhost -U username -d ninjaserver --schema-only > schema_backup.sql
+
+# Nur Daten
+pg_dump -h localhost -U username -d ninjaserver --data-only > data_backup.sql
+
+# Komprimiertes Backup
+pg_dump -h localhost -U username -d ninjaserver | gzip > ninjaserver_backup.sql.gz
+```
+
+### Wiederherstellung
+```bash
+# Vollständige Wiederherstellung
+psql -h localhost -U username -d ninjaserver < ninjaserver_backup.sql
+
+# Schema wiederherstellen
+psql -h localhost -U username -d ninjaserver < schema_backup.sql
+
+# Daten wiederherstellen
+psql -h localhost -U username -d ninjaserver < data_backup.sql
+```
+
+### Wartungsaufgaben
+```sql
+-- Tabellen analysieren
+ANALYZE;
+
+-- Indizes neu aufbauen
+REINDEX DATABASE ninjaserver;
+
+-- Vakuum durchführen
+VACUUM ANALYZE;
+
+-- Speicher freigeben
+VACUUM FULL;
+```
+
+### Monitoring
+```sql
+-- Aktive Verbindungen
+SELECT 
+    pid,
+    usename,
+    application_name,
+    client_addr,
+    state,
+    query_start,
+    query
+FROM pg_stat_activity 
+WHERE state = 'active';
+
+-- Locks
+SELECT 
+    pid,
+    mode,
+    locktype,
+    relation::regclass,
+    granted
+FROM pg_locks 
+WHERE NOT granted;
+
+-- Wartende Queries
+SELECT 
+    pid,
+    usename,
+    application_name,
+    state,
+    query_start,
+    query
+FROM pg_stat_activity 
+WHERE state = 'waiting';
+```
+
+### Sicherheit
+```sql
+-- Benutzerrechte prüfen
+SELECT 
+    usename,
+    usesuper,
+    usecreatedb,
+    usebypassrls
+FROM pg_user;
+
+-- Tabellenrechte prüfen
+SELECT 
+    schemaname,
+    tablename,
+    tableowner
+FROM pg_tables 
+WHERE schemaname = 'public';
+
+-- Verbindungslimits
+SELECT 
+    usename,
+    connlimit
+FROM pg_user;
+```
+
+---
+
+**Hinweis:** Für detaillierte API-Dokumentation siehe [API Referenz](API-Referenz) und für Achievement-Details siehe [Achievement System](Achievement-System).
diff --git a/wiki/Deployment.md b/wiki/Deployment.md
new file mode 100644
index 0000000..0993edb
--- /dev/null
+++ b/wiki/Deployment.md
@@ -0,0 +1,642 @@
+# 🚀 Deployment
+
+Anleitung für das Deployment des Ninja Cross Parkour Systems in verschiedenen Umgebungen.
+
+## 📋 Inhaltsverzeichnis
+
+- [🏗️ Deployment-Übersicht](#️-deployment-übersicht)
+- [🔧 Vorbereitung](#-vorbereitung)
+- [🐳 Docker-Deployment](#-docker-deployment)
+- [☁️ Cloud-Deployment](#️-cloud-deployment)
+- [🖥️ VPS-Deployment](#️-vps-deployment)
+- [🔧 Konfiguration](#-konfiguration)
+- [📊 Monitoring](#-monitoring)
+- [🔄 CI/CD](#-cicd)
+
+## 🏗️ Deployment-Übersicht
+
+### Deployment-Optionen
+- **Docker** - Containerisierte Bereitstellung
+- **Cloud** - AWS, Azure, Google Cloud
+- **VPS** - Virtuelle private Server
+- **On-Premise** - Lokale Server
+
+### System-Anforderungen
+- **CPU:** 2+ Kerne
+- **RAM:** 4+ GB
+- **Storage:** 50+ GB SSD
+- **Network:** 100+ Mbps
+
+## 🔧 Vorbereitung
+
+### Code vorbereiten
+```bash
+# Repository klonen
+git clone <repository-url>
+cd ninjaserver
+
+# Abhängigkeiten installieren
+npm install
+
+# Produktions-Build erstellen
+npm run build
+
+# Tests ausführen
+npm test
+```
+
+### Umgebungsvariablen
+```bash
+# .env.production erstellen
+cp .env.example .env.production
+
+# Produktionswerte setzen
+NODE_ENV=production
+PORT=3000
+DB_HOST=production-db-host
+DB_PORT=5432
+DB_NAME=ninjaserver
+DB_USER=ninja_user
+DB_PASSWORD=secure_password
+JWT_SECRET=your_jwt_secret_here
+SESSION_SECRET=your_session_secret_here
+```
+
+### Datenbank vorbereiten
+```sql
+-- Produktionsdatenbank erstellen
+CREATE DATABASE ninjaserver;
+CREATE USER ninja_user WITH PASSWORD 'secure_password';
+GRANT ALL PRIVILEGES ON DATABASE ninjaserver TO ninja_user;
+
+-- Schema initialisieren
+\c ninjaserver
+\i scripts/init-db.sql
+```
+
+## 🐳 Docker-Deployment
+
+### Dockerfile
+```dockerfile
+# Multi-stage build
+FROM node:18-alpine AS builder
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+
+FROM node:18-alpine AS runtime
+
+# Sicherheitsupdates
+RUN apk update && apk upgrade
+
+# Nicht-root Benutzer erstellen
+RUN addgroup -g 1001 -S nodejs
+RUN adduser -S ninja -u 1001
+
+WORKDIR /app
+
+# Abhängigkeiten kopieren
+COPY --from=builder /app/node_modules ./node_modules
+COPY . .
+
+# Berechtigungen setzen
+RUN chown -R ninja:nodejs /app
+USER ninja
+
+# Port freigeben
+EXPOSE 3000
+
+# Health Check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:3000/health || exit 1
+
+# Anwendung starten
+CMD ["npm", "start"]
+```
+
+### Docker Compose
+```yaml
+version: '3.8'
+
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - DB_HOST=postgres
+      - DB_PORT=5432
+      - DB_NAME=ninjaserver
+      - DB_USER=ninja_user
+      - DB_PASSWORD=secure_password
+    depends_on:
+      - postgres
+      - redis
+    volumes:
+      - ./logs:/app/logs
+    restart: unless-stopped
+
+  postgres:
+    image: postgres:15-alpine
+    environment:
+      - POSTGRES_DB=ninjaserver
+      - POSTGRES_USER=ninja_user
+      - POSTGRES_PASSWORD=secure_password
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+      - ./scripts/init-db.sql:/docker-entrypoint-initdb.d/init-db.sql
+    ports:
+      - "5432:5432"
+    restart: unless-stopped
+
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    restart: unless-stopped
+
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf
+      - ./ssl:/etc/nginx/ssl
+    depends_on:
+      - app
+    restart: unless-stopped
+
+volumes:
+  postgres_data:
+  redis_data:
+```
+
+### Deployment-Skript
+```bash
+#!/bin/bash
+# deploy.sh
+
+set -e
+
+echo "🚀 Starting deployment..."
+
+# Docker Images bauen
+echo "📦 Building Docker images..."
+docker-compose build
+
+# Alte Container stoppen
+echo "🛑 Stopping old containers..."
+docker-compose down
+
+# Neue Container starten
+echo "▶️ Starting new containers..."
+docker-compose up -d
+
+# Health Check
+echo "🔍 Checking health..."
+sleep 30
+curl -f http://localhost:3000/health || exit 1
+
+echo "✅ Deployment completed successfully!"
+```
+
+## ☁️ Cloud-Deployment
+
+### AWS Deployment
+
+#### EC2-Instanz
+```bash
+# EC2-Instanz starten
+aws ec2 run-instances \
+  --image-id ami-0c02fb55956c7d316 \
+  --instance-type t3.medium \
+  --key-name ninja-key \
+  --security-groups ninja-sg \
+  --user-data file://user-data.sh
+```
+
+#### RDS-Datenbank
+```bash
+# RDS-Instanz erstellen
+aws rds create-db-instance \
+  --db-instance-identifier ninja-db \
+  --db-instance-class db.t3.micro \
+  --engine postgres \
+  --master-username ninja_user \
+  --master-user-password secure_password \
+  --allocated-storage 20
+```
+
+#### Load Balancer
+```bash
+# Application Load Balancer erstellen
+aws elbv2 create-load-balancer \
+  --name ninja-alb \
+  --subnets subnet-12345 subnet-67890 \
+  --security-groups sg-12345
+```
+
+### Azure Deployment
+
+#### App Service
+```bash
+# App Service erstellen
+az webapp create \
+  --resource-group ninja-rg \
+  --plan ninja-plan \
+  --name ninja-app \
+  --runtime "NODE|18-lts"
+```
+
+#### PostgreSQL
+```bash
+# PostgreSQL-Server erstellen
+az postgres flexible-server create \
+  --resource-group ninja-rg \
+  --name ninja-db \
+  --admin-user ninja_user \
+  --admin-password secure_password \
+  --sku-name Standard_B1ms
+```
+
+### Google Cloud Deployment
+
+#### Cloud Run
+```yaml
+# cloudbuild.yaml
+steps:
+  - name: 'gcr.io/cloud-builders/docker'
+    args: ['build', '-t', 'gcr.io/$PROJECT_ID/ninja-app', '.']
+  - name: 'gcr.io/cloud-builders/docker'
+    args: ['push', 'gcr.io/$PROJECT_ID/ninja-app']
+  - name: 'gcr.io/cloud-builders/gcloud'
+    args: ['run', 'deploy', 'ninja-app', '--image', 'gcr.io/$PROJECT_ID/ninja-app', '--region', 'europe-west1']
+```
+
+## 🖥️ VPS-Deployment
+
+### Server-Setup
+```bash
+#!/bin/bash
+# server-setup.sh
+
+# System aktualisieren
+sudo apt update && sudo apt upgrade -y
+
+# Node.js installieren
+curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
+sudo apt-get install -y nodejs
+
+# PostgreSQL installieren
+sudo apt install postgresql postgresql-contrib -y
+
+# Nginx installieren
+sudo apt install nginx -y
+
+# PM2 installieren
+sudo npm install -g pm2
+
+# Firewall konfigurieren
+sudo ufw allow 22
+sudo ufw allow 80
+sudo ufw allow 443
+sudo ufw enable
+```
+
+### Anwendung deployen
+```bash
+#!/bin/bash
+# deploy-vps.sh
+
+# Code aktualisieren
+git pull origin main
+
+# Abhängigkeiten installieren
+npm install --production
+
+# Datenbank migrieren
+npm run migrate
+
+# Anwendung starten
+pm2 start ecosystem.config.js
+
+# Nginx konfigurieren
+sudo cp nginx.conf /etc/nginx/sites-available/ninja
+sudo ln -s /etc/nginx/sites-available/ninja /etc/nginx/sites-enabled/
+sudo nginx -t
+sudo systemctl reload nginx
+```
+
+### PM2-Konfiguration
+```javascript
+// ecosystem.config.js
+module.exports = {
+  apps: [{
+    name: 'ninja-app',
+    script: 'server.js',
+    instances: 'max',
+    exec_mode: 'cluster',
+    env: {
+      NODE_ENV: 'production',
+      PORT: 3000
+    },
+    error_file: './logs/err.log',
+    out_file: './logs/out.log',
+    log_file: './logs/combined.log',
+    time: true
+  }]
+};
+```
+
+## 🔧 Konfiguration
+
+### Nginx-Konfiguration
+```nginx
+# nginx.conf
+upstream ninja_app {
+    server 127.0.0.1:3000;
+}
+
+server {
+    listen 80;
+    server_name ninja.reptilfpv.de;
+    return 301 https://$server_name$request_uri;
+}
+
+server {
+    listen 443 ssl http2;
+    server_name ninja.reptilfpv.de;
+
+    ssl_certificate /etc/nginx/ssl/cert.pem;
+    ssl_certificate_key /etc/nginx/ssl/key.pem;
+    ssl_protocols TLSv1.2 TLSv1.3;
+    ssl_ciphers ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256;
+    ssl_prefer_server_ciphers off;
+
+    # Security Headers
+    add_header X-Frame-Options DENY;
+    add_header X-Content-Type-Options nosniff;
+    add_header X-XSS-Protection "1; mode=block";
+    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
+
+    # Rate Limiting
+    limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;
+    limit_req zone=api burst=20 nodelay;
+
+    location / {
+        proxy_pass http://ninja_app;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_cache_bypass $http_upgrade;
+    }
+
+    # Static Files
+    location /static/ {
+        alias /var/www/ninja/public/;
+        expires 1y;
+        add_header Cache-Control "public, immutable";
+    }
+}
+```
+
+### SSL-Zertifikat
+```bash
+# Let's Encrypt
+sudo apt install certbot python3-certbot-nginx -y
+sudo certbot --nginx -d ninja.reptilfpv.de
+
+# Automatische Erneuerung
+echo "0 12 * * * /usr/bin/certbot renew --quiet" | sudo crontab -
+```
+
+### Datenbank-Backup
+```bash
+#!/bin/bash
+# backup.sh
+
+# Tägliches Backup
+pg_dump -h localhost -U ninja_user -d ninjaserver | gzip > backup_$(date +%Y%m%d).sql.gz
+
+# Alte Backups löschen (älter als 30 Tage)
+find /backups -name "backup_*.sql.gz" -mtime +30 -delete
+
+# Backup nach S3 hochladen
+aws s3 cp backup_$(date +%Y%m%d).sql.gz s3://ninja-backups/
+```
+
+## 📊 Monitoring
+
+### Application Monitoring
+```javascript
+// monitoring.js
+const prometheus = require('prom-client');
+
+// Metriken definieren
+const httpRequestDuration = new prometheus.Histogram({
+  name: 'http_request_duration_seconds',
+  help: 'Duration of HTTP requests in seconds',
+  labelNames: ['method', 'route', 'status_code']
+});
+
+const activeConnections = new prometheus.Gauge({
+  name: 'active_connections',
+  help: 'Number of active connections'
+});
+
+// Metriken-Endpoint
+app.get('/metrics', (req, res) => {
+  res.set('Content-Type', prometheus.register.contentType);
+  res.end(prometheus.register.metrics());
+});
+```
+
+### Log-Monitoring
+```bash
+# Logstash-Konfiguration
+input {
+  file {
+    path => "/var/log/ninja/*.log"
+    type => "ninja-logs"
+  }
+}
+
+filter {
+  if [type] == "ninja-logs" {
+    grok {
+      match => { "message" => "%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:level} %{GREEDYDATA:message}" }
+    }
+  }
+}
+
+output {
+  elasticsearch {
+    hosts => ["localhost:9200"]
+    index => "ninja-logs-%{+YYYY.MM.dd}"
+  }
+}
+```
+
+### Alerting
+```yaml
+# alertmanager.yml
+global:
+  smtp_smarthost: 'localhost:587'
+  smtp_from: 'alerts@ninjaparkour.de'
+
+route:
+  group_by: ['alertname']
+  group_wait: 10s
+  group_interval: 10s
+  repeat_interval: 1h
+  receiver: 'web.hook'
+
+receivers:
+- name: 'web.hook'
+  email_configs:
+  - to: 'admin@ninjaparkour.de'
+    subject: 'Ninja Parkour Alert: {{ .GroupLabels.alertname }}'
+    body: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'
+```
+
+## 🔄 CI/CD
+
+### GitHub Actions
+```yaml
+# .github/workflows/deploy.yml
+name: Deploy
+
+on:
+  push:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-node@v3
+      with:
+        node-version: '18'
+    - run: npm ci
+    - run: npm test
+
+  deploy:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Deploy to production
+      run: |
+        ssh user@server 'cd /var/www/ninja && git pull && npm install && pm2 restart ninja-app'
+```
+
+### GitLab CI
+```yaml
+# .gitlab-ci.yml
+stages:
+  - test
+  - deploy
+
+test:
+  stage: test
+  script:
+    - npm ci
+    - npm test
+
+deploy:
+  stage: deploy
+  script:
+    - ssh user@server 'cd /var/www/ninja && git pull && npm install && pm2 restart ninja-app'
+  only:
+    - main
+```
+
+### Jenkins Pipeline
+```groovy
+// Jenkinsfile
+pipeline {
+    agent any
+    
+    stages {
+        stage('Test') {
+            steps {
+                sh 'npm ci'
+                sh 'npm test'
+            }
+        }
+        
+        stage('Deploy') {
+            steps {
+                sh 'ssh user@server "cd /var/www/ninja && git pull && npm install && pm2 restart ninja-app"'
+            }
+        }
+    }
+}
+```
+
+## 🔧 Wartung
+
+### Automatische Updates
+```bash
+#!/bin/bash
+# auto-update.sh
+
+# System-Updates
+sudo apt update && sudo apt upgrade -y
+
+# Anwendung-Updates
+cd /var/www/ninja
+git pull origin main
+npm install --production
+pm2 restart ninja-app
+
+# Datenbank-Updates
+npm run migrate
+```
+
+### Health Checks
+```bash
+#!/bin/bash
+# health-check.sh
+
+# Anwendung prüfen
+curl -f http://localhost:3000/health || exit 1
+
+# Datenbank prüfen
+psql -d ninjaserver -c "SELECT NOW();" || exit 1
+
+# Speicher prüfen
+if [ $(df / | awk 'NR==2{print $5}' | sed 's/%//') -gt 80 ]; then
+    echo "Disk space low"
+    exit 1
+fi
+```
+
+### Rollback-Strategie
+```bash
+#!/bin/bash
+# rollback.sh
+
+# Vorherige Version wiederherstellen
+cd /var/www/ninja
+git checkout HEAD~1
+npm install --production
+pm2 restart ninja-app
+
+# Datenbank-Rollback
+psql -d ninjaserver < backup_previous.sql
+```
+
+---
+
+**Hinweis:** Diese Deployment-Anleitung sollte an Ihre spezifischen Anforderungen angepasst werden. Testen Sie alle Schritte in einer Staging-Umgebung vor der Produktionsbereitstellung.
diff --git a/wiki/Entwicklerhandbuch.md b/wiki/Entwicklerhandbuch.md
new file mode 100644
index 0000000..aec5573
--- /dev/null
+++ b/wiki/Entwicklerhandbuch.md
@@ -0,0 +1,589 @@
+# 🔧 Entwicklerhandbuch
+
+Technische Dokumentation für Entwickler des Ninja Cross Parkour Systems.
+
+## 📋 Inhaltsverzeichnis
+
+- [🏗️ System-Architektur](#️-system-architektur)
+- [🛠️ Entwicklungsumgebung](#️-entwicklungsumgebung)
+- [📡 API-Integration](#-api-integration)
+- [🗄️ Datenbank-Schema](#-datenbank-schema)
+- [🔐 Authentifizierung](#-authentifizierung)
+- [🧪 Testing](#-testing)
+- [🚀 Deployment](#-deployment)
+- [📊 Monitoring](#-monitoring)
+- [🔧 Wartung](#-wartung)
+
+## 🏗️ System-Architektur
+
+### Übersicht
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Frontend      │    │   Backend       │    │   Database      │
+│   (Web UI)      │◄──►│   (Node.js)     │◄──►│   (PostgreSQL)  │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+         │                       │                       │
+         │                       │                       │
+         ▼                       ▼                       ▼
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   RFID Reader   │    │   API Endpoints │    │   Achievement   │
+│   (Hardware)    │    │   (REST)        │    │   System        │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+```
+
+### Technologie-Stack
+- **Backend:** Node.js + Express.js
+- **Datenbank:** PostgreSQL
+- **Frontend:** HTML5 + CSS3 + JavaScript
+- **Authentifizierung:** JWT + bcrypt
+- **API:** RESTful API
+- **Maps:** Leaflet.js + OpenStreetMap
+- **RFID:** Hardware-Integration
+
+### Projektstruktur
+```
+ninjaserver/
+├── server.js              # Hauptserver-Datei
+├── routes/
+│   ├── api.js            # API-Routen
+│   ├── public.js         # Öffentliche Routen
+│   ├── private.js        # Private Routen
+│   ├── web.js            # Web-Routen
+│   └── admin.js          # Admin-Routen
+├── middleware/
+│   ├── auth.js           # Authentifizierung
+│   ├── validation.js     # Eingabe-Validierung
+│   └── logging.js        # Logging
+├── models/
+│   ├── Player.js         # Spieler-Modell
+│   ├── Time.js           # Zeit-Modell
+│   ├── Location.js       # Standort-Modell
+│   └── Achievement.js    # Achievement-Modell
+├── scripts/
+│   ├── init-db.js        # Datenbankinitialisierung
+│   ├── create-user.js    # Benutzer-Erstellung
+│   └── daily_achievements.js # Tägliche Achievements
+├── public/
+│   ├── index.html        # Hauptanwendung
+│   ├── login.html        # Login-Seite
+│   ├── css/              # Stylesheets
+│   └── js/               # JavaScript
+├── test/
+│   ├── api.test.js       # API-Tests
+│   ├── unit.test.js      # Unit-Tests
+│   └── integration.test.js # Integration-Tests
+└── docs/
+    ├── API.md            # API-Dokumentation
+    ├── ACHIEVEMENTS.md   # Achievement-Dokumentation
+    └── wiki/             # Wiki-Dokumentation
+```
+
+## 🛠️ Entwicklungsumgebung
+
+### Voraussetzungen
+- **Node.js** v16 oder höher
+- **PostgreSQL** 12 oder höher
+- **Git** für Versionskontrolle
+- **npm** oder **yarn** für Paketverwaltung
+
+### Setup
+```bash
+# Repository klonen
+git clone <repository-url>
+cd ninjaserver
+
+# Abhängigkeiten installieren
+npm install
+
+# Umgebungsvariablen konfigurieren
+cp .env.example .env
+# .env-Datei bearbeiten
+
+# Datenbank initialisieren
+npm run init-db
+
+# Entwicklungsserver starten
+npm run dev
+```
+
+### Entwicklungsskripte
+```bash
+# Entwicklungsserver mit Auto-Reload
+npm run dev
+
+# Tests ausführen
+npm test
+
+# Linting
+npm run lint
+
+# Datenbank zurücksetzen
+npm run reset-db
+
+# API-Dokumentation generieren
+npm run docs
+```
+
+### IDE-Empfehlungen
+- **Visual Studio Code** mit Extensions:
+  - ES6 code snippets
+  - PostgreSQL
+  - REST Client
+  - GitLens
+
+## 📡 API-Integration
+
+### Authentifizierung
+```javascript
+// API-Key Authentifizierung
+const headers = {
+  'Authorization': 'Bearer YOUR_API_KEY',
+  'Content-Type': 'application/json'
+};
+
+// Session-basierte Authentifizierung
+const session = await authenticateUser(username, password);
+```
+
+### API-Client Beispiel
+```javascript
+class NinjaParkourAPI {
+  constructor(apiKey, baseURL = 'http://localhost:3000') {
+    this.apiKey = apiKey;
+    this.baseURL = baseURL;
+  }
+
+  async request(endpoint, options = {}) {
+    const url = `${this.baseURL}${endpoint}`;
+    const config = {
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+        ...options.headers
+      },
+      ...options
+    };
+
+    const response = await fetch(url, config);
+    return response.json();
+  }
+
+  // Spieler erstellen
+  async createPlayer(playerData) {
+    return this.request('/api/v1/public/players', {
+      method: 'POST',
+      body: JSON.stringify(playerData)
+    });
+  }
+
+  // Zeit messen
+  async recordTime(timeData) {
+    return this.request('/api/v1/private/create-time', {
+      method: 'POST',
+      body: JSON.stringify(timeData)
+    });
+  }
+
+  // Achievements abrufen
+  async getAchievements(playerId) {
+    return this.request(`/api/achievements/player/${playerId}`);
+  }
+}
+
+// Verwendung
+const api = new NinjaParkourAPI('your-api-key');
+const player = await api.createPlayer({
+  firstname: 'Max',
+  lastname: 'Mustermann',
+  birthdate: '1990-01-01',
+  rfiduid: 'AA:BB:CC:DD'
+});
+```
+
+### WebSocket Integration
+```javascript
+// Real-time Updates
+const socket = io('http://localhost:3000');
+
+socket.on('timeRecorded', (data) => {
+  console.log('Neue Zeit:', data);
+  updateLeaderboard(data);
+});
+
+socket.on('achievementEarned', (data) => {
+  console.log('Neues Achievement:', data);
+  showNotification(data);
+});
+```
+
+## 🗄️ Datenbank-Schema
+
+### Tabellen-Übersicht
+```sql
+-- Spieler
+CREATE TABLE players (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    firstname VARCHAR(50) NOT NULL,
+    lastname VARCHAR(50) NOT NULL,
+    birthdate DATE NOT NULL,
+    rfiduid VARCHAR(20) UNIQUE,
+    supabase_user_id UUID,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Standorte
+CREATE TABLE locations (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name VARCHAR(255) UNIQUE NOT NULL,
+    latitude DECIMAL(10, 8) NOT NULL,
+    longitude DECIMAL(11, 8) NOT NULL,
+    time_threshold JSONB DEFAULT '{"seconds": 120}',
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Zeiten
+CREATE TABLE times (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    player_id UUID REFERENCES players(id),
+    location_id UUID REFERENCES locations(id),
+    recorded_time JSONB NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Achievements
+CREATE TABLE achievements (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name VARCHAR(255) NOT NULL,
+    description TEXT,
+    category VARCHAR(50) NOT NULL,
+    condition_type VARCHAR(50) NOT NULL,
+    condition_value INTEGER NOT NULL,
+    icon VARCHAR(10),
+    points INTEGER DEFAULT 0,
+    is_active BOOLEAN DEFAULT true,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Spieler-Achievements
+CREATE TABLE player_achievements (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    player_id UUID REFERENCES players(id),
+    achievement_id UUID REFERENCES achievements(id),
+    earned_at TIMESTAMP,
+    progress INTEGER DEFAULT 0,
+    is_completed BOOLEAN DEFAULT false,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+### Indizes
+```sql
+-- Performance-Indizes
+CREATE INDEX idx_times_player_id ON times(player_id);
+CREATE INDEX idx_times_location_id ON times(location_id);
+CREATE INDEX idx_times_created_at ON times(created_at);
+CREATE INDEX idx_player_achievements_player_id ON player_achievements(player_id);
+CREATE INDEX idx_player_achievements_achievement_id ON player_achievements(achievement_id);
+```
+
+### PostgreSQL Funktionen
+```sql
+-- Achievement-Prüfung
+CREATE OR REPLACE FUNCTION check_all_achievements(player_uuid UUID)
+RETURNS VOID AS $$
+BEGIN
+    PERFORM check_consistency_achievements(player_uuid);
+    PERFORM check_improvement_achievements(player_uuid);
+    PERFORM check_seasonal_achievements(player_uuid);
+END;
+$$ LANGUAGE plpgsql;
+```
+
+## 🔐 Authentifizierung
+
+### API-Key Authentifizierung
+```javascript
+// Middleware für API-Key
+const authenticateAPIKey = (req, res, next) => {
+  const authHeader = req.headers.authorization;
+  const token = authHeader && authHeader.split(' ')[1];
+
+  if (!token) {
+    return res.status(401).json({ error: 'API-Key erforderlich' });
+  }
+
+  // Token validieren
+  const isValid = validateAPIKey(token);
+  if (!isValid) {
+    return res.status(401).json({ error: 'Ungültiger API-Key' });
+  }
+
+  req.apiKey = token;
+  next();
+};
+```
+
+### Session-basierte Authentifizierung
+```javascript
+// Session-Middleware
+const authenticateSession = (req, res, next) => {
+  if (!req.session || !req.session.userId) {
+    return res.status(401).json({ error: 'Nicht authentifiziert' });
+  }
+
+  req.userId = req.session.userId;
+  next();
+};
+```
+
+### JWT-Token
+```javascript
+// JWT-Token generieren
+const generateJWT = (user) => {
+  return jwt.sign(
+    { userId: user.id, username: user.username },
+    process.env.JWT_SECRET,
+    { expiresIn: '24h' }
+  );
+};
+
+// JWT-Token validieren
+const validateJWT = (token) => {
+  try {
+    return jwt.verify(token, process.env.JWT_SECRET);
+  } catch (error) {
+    return null;
+  }
+};
+```
+
+## 🧪 Testing
+
+### Unit-Tests
+```javascript
+// test/unit/Player.test.js
+const { Player } = require('../../models/Player');
+
+describe('Player Model', () => {
+  test('should create player with valid data', () => {
+    const playerData = {
+      firstname: 'Max',
+      lastname: 'Mustermann',
+      birthdate: '1990-01-01',
+      rfiduid: 'AA:BB:CC:DD'
+    };
+
+    const player = new Player(playerData);
+    expect(player.firstname).toBe('Max');
+    expect(player.lastname).toBe('Mustermann');
+  });
+});
+```
+
+### Integration-Tests
+```javascript
+// test/integration/api.test.js
+const request = require('supertest');
+const app = require('../../server');
+
+describe('API Endpoints', () => {
+  test('POST /api/v1/public/players', async () => {
+    const playerData = {
+      firstname: 'Max',
+      lastname: 'Mustermann',
+      birthdate: '1990-01-01',
+      rfiduid: 'AA:BB:CC:DD'
+    };
+
+    const response = await request(app)
+      .post('/api/v1/public/players')
+      .send(playerData)
+      .expect(201);
+
+    expect(response.body.success).toBe(true);
+    expect(response.body.data.firstname).toBe('Max');
+  });
+});
+```
+
+### API-Tests ausführen
+```bash
+# Alle Tests
+npm test
+
+# Unit-Tests
+npm run test:unit
+
+# Integration-Tests
+npm run test:integration
+
+# Coverage-Report
+npm run test:coverage
+```
+
+## 🚀 Deployment
+
+### Produktionsumgebung
+```bash
+# Abhängigkeiten installieren
+npm install --production
+
+# Umgebungsvariablen setzen
+export NODE_ENV=production
+export DB_HOST=production-db-host
+export DB_PASSWORD=secure-password
+
+# Server starten
+npm start
+```
+
+### Docker-Container
+```dockerfile
+# Dockerfile
+FROM node:16-alpine
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm install --production
+
+COPY . .
+EXPOSE 3000
+
+CMD ["npm", "start"]
+```
+
+### Nginx-Konfiguration
+```nginx
+server {
+    listen 80;
+    server_name ninja.reptilfpv.de;
+
+    location / {
+        proxy_pass http://localhost:3000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_cache_bypass $http_upgrade;
+    }
+}
+```
+
+### SSL-Zertifikat
+```bash
+# Let's Encrypt
+certbot --nginx -d ninja.reptilfpv.de
+```
+
+## 📊 Monitoring
+
+### Logging
+```javascript
+// Winston Logger
+const winston = require('winston');
+
+const logger = winston.createLogger({
+  level: 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  transports: [
+    new winston.transports.File({ filename: 'logs/error.log', level: 'error' }),
+    new winston.transports.File({ filename: 'logs/combined.log' })
+  ]
+});
+```
+
+### Health-Checks
+```javascript
+// Health-Check Endpoint
+app.get('/health', async (req, res) => {
+  try {
+    // Datenbank-Verbindung prüfen
+    await db.query('SELECT 1');
+    
+    res.json({
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime()
+    });
+  } catch (error) {
+    res.status(500).json({
+      status: 'unhealthy',
+      error: error.message
+    });
+  }
+});
+```
+
+### Metriken
+```javascript
+// Prometheus-Metriken
+const prometheus = require('prom-client');
+
+const httpRequestDuration = new prometheus.Histogram({
+  name: 'http_request_duration_seconds',
+  help: 'Duration of HTTP requests in seconds',
+  labelNames: ['method', 'route', 'status_code']
+});
+
+const activeConnections = new prometheus.Gauge({
+  name: 'active_connections',
+  help: 'Number of active connections'
+});
+```
+
+## 🔧 Wartung
+
+### Datenbank-Backup
+```bash
+# Backup erstellen
+pg_dump -h localhost -U username -d ninjaserver > backup.sql
+
+# Backup wiederherstellen
+psql -h localhost -U username -d ninjaserver < backup.sql
+```
+
+### Log-Rotation
+```bash
+# Logrotate-Konfiguration
+/var/log/ninjaserver/*.log {
+    daily
+    missingok
+    rotate 30
+    compress
+    delaycompress
+    notifempty
+    create 644 node node
+    postrotate
+        systemctl reload ninjaserver
+    endscript
+}
+```
+
+### Performance-Optimierung
+```sql
+-- Query-Performance analysieren
+EXPLAIN ANALYZE SELECT * FROM times 
+WHERE player_id = 'uuid' 
+ORDER BY created_at DESC;
+
+-- Indizes hinzufügen
+CREATE INDEX CONCURRENTLY idx_times_player_created 
+ON times(player_id, created_at DESC);
+```
+
+### Sicherheits-Updates
+```bash
+# Abhängigkeiten aktualisieren
+npm audit
+npm audit fix
+
+# Sicherheits-Updates
+npm update
+```
+
+---
+
+**Hinweis:** Für detaillierte API-Dokumentation siehe [API Referenz](API-Referenz) und für Achievement-Details siehe [Achievement System](Achievement-System).
diff --git a/wiki/FAQ.md b/wiki/FAQ.md
new file mode 100644
index 0000000..de992f0
--- /dev/null
+++ b/wiki/FAQ.md
@@ -0,0 +1,380 @@
+# ❓ FAQ - Häufige Fragen
+
+Antworten auf häufig gestellte Fragen zum Ninja Cross Parkour System.
+
+## 🚀 Installation und Setup
+
+### Wie installiere ich das System?
+Siehe [Schnellstart](Schnellstart) für eine detaillierte Anleitung. Kurz gesagt:
+1. Repository klonen
+2. `npm install` ausführen
+3. `.env`-Datei konfigurieren
+4. `npm run init-db` ausführen
+5. `npm start` starten
+
+### Welche Voraussetzungen benötige ich?
+- Node.js v16 oder höher
+- PostgreSQL 12 oder höher
+- npm oder yarn
+- Git für die Installation
+
+### Wie konfiguriere ich die Datenbank?
+Bearbeiten Sie die `.env`-Datei mit Ihren Datenbankdaten:
+```env
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=ninjaserver
+DB_USER=your_username
+DB_PASSWORD=your_password
+```
+
+### Wie erstelle ich den ersten Admin-Benutzer?
+```bash
+npm run create-user
+```
+Standard-Anmeldedaten: `admin` / `admin123`
+
+## 🔐 Authentifizierung
+
+### Wie funktioniert die API-Authentifizierung?
+Das System verwendet API-Keys für die Authentifizierung. Generieren Sie einen Key:
+```bash
+curl -X POST http://localhost:3000/api/v1/web/generate-api-key \
+  -H "Content-Type: application/json" \
+  -d '{"description": "Mein API Key"}'
+```
+
+### Wie verwende ich den API-Key?
+Fügen Sie den Key in den Authorization Header ein:
+```http
+Authorization: Bearer YOUR_API_KEY_HERE
+```
+
+### Wie lange sind API-Keys gültig?
+API-Keys sind standardmäßig unbegrenzt gültig, können aber mit einem Ablaufdatum versehen werden.
+
+### Kann ich mehrere API-Keys haben?
+Ja, Sie können beliebig viele API-Keys erstellen, z.B. für verschiedene Anwendungen oder Benutzer.
+
+## 🏃‍♂️ Spieler und Zeiten
+
+### Wie registriere ich einen neuen Spieler?
+```bash
+curl -X POST http://localhost:3000/api/v1/public/players \
+  -H "Content-Type: application/json" \
+  -d '{"firstname": "Max", "lastname": "Mustermann", "birthdate": "1990-01-01", "rfiduid": "AA:BB:CC:DD"}'
+```
+
+### Wie verknüpfe ich eine RFID-Karte mit einem Spieler?
+```bash
+curl -X POST http://localhost:3000/api/v1/public/link-by-rfid \
+  -H "Content-Type: application/json" \
+  -d '{"rfiduid": "AA:BB:CC:DD", "supabase_user_id": "uuid-here"}'
+```
+
+### Wie messe ich eine Zeit?
+```bash
+curl -X POST http://localhost:3000/api/v1/private/create-time \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"player_id": "AA:BB:CC:DD", "location_id": "Standort-Name", "recorded_time": "01:23.456"}'
+```
+
+### Welches Zeitformat wird verwendet?
+Zeiten werden im Format `MM:SS.mmm` gespeichert:
+- Minuten:Sekunden.Millisekunden
+- Beispiel: `01:23.456` = 1 Minute, 23 Sekunden, 456 Millisekunden
+
+### Was ist eine gültige Zeit?
+- **Minimum:** 30 Sekunden
+- **Maximum:** 10 Minuten
+- **Schwelle:** Konfigurierbar pro Standort (Standard: 120 Sekunden)
+
+## 🏆 Achievements
+
+### Wie funktioniert das Achievement-System?
+Das System überprüft automatisch täglich alle Spieler auf neue Achievements. Siehe [Achievement System](Achievement-System) für Details.
+
+### Wann werden Achievements vergeben?
+- **Automatisch:** Täglich um 23:59 Uhr
+- **Manuell:** Über API-Endpoints
+- **Sofort:** Bei bestimmten Aktionen
+
+### Wie viele Achievements gibt es?
+Das System hat 32 verschiedene Achievements in 4 Kategorien:
+- Konsistenz-basierte (8)
+- Verbesserungs-basierte (4)
+- Saisonale (4)
+- Monatliche (12)
+- Jahreszeiten (4)
+
+### Wie rufe ich Achievements ab?
+```bash
+# Alle Achievements
+curl http://localhost:3000/api/achievements
+
+# Spieler-Achievements
+curl http://localhost:3000/api/achievements/player/{playerId}
+
+# Spieler-Statistiken
+curl http://localhost:3000/api/achievements/player/{playerId}/stats
+```
+
+## 📍 Standorte
+
+### Wie erstelle ich einen neuen Standort?
+```bash
+curl -X POST http://localhost:3000/api/v1/private/create-location \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "München", "latitude": 48.1351, "longitude": 11.5820}'
+```
+
+### Wie ändere ich die Zeit-Schwelle eines Standorts?
+```bash
+curl -X PUT http://localhost:3000/api/v1/private/locations/{id}/threshold \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"threshold_seconds": 120}'
+```
+
+### Wie viele Standorte kann ich haben?
+Es gibt keine Begrenzung der Anzahl der Standorte.
+
+## 🔧 Technische Fragen
+
+### Wie starte ich den Server?
+```bash
+# Entwicklung
+npm run dev
+
+# Produktion
+npm start
+```
+
+### Wie überwache ich den Server?
+```bash
+# Logs anzeigen
+tail -f logs/server.log
+
+# Achievement-Logs
+tail -f /var/log/ninjaserver_achievements.log
+
+# Datenbank-Status
+psql -d ninjaserver -c "SELECT NOW();"
+```
+
+### Wie teste ich die API?
+```bash
+# Test-Skript ausführen
+node test-api.js
+
+# Einzelne Endpoints testen
+curl http://localhost:3000/api/v1/public/locations
+```
+
+### Wie sichere ich die Datenbank?
+```bash
+# Vollständiges Backup
+pg_dump -h localhost -U username -d ninjaserver > backup.sql
+
+# Wiederherstellung
+psql -h localhost -U username -d ninjaserver < backup.sql
+```
+
+## 🐛 Fehlerbehebung
+
+### "Port 3000 bereits belegt"
+```bash
+# Port freigeben
+sudo lsof -ti:3000 | xargs kill -9
+
+# Oder anderen Port verwenden
+PORT=3001 npm start
+```
+
+### "Datenbank-Verbindung fehlgeschlagen"
+1. PostgreSQL-Service prüfen: `sudo systemctl status postgresql`
+2. Datenbank-Credentials in `.env` prüfen
+3. Firewall-Einstellungen prüfen
+
+### "API-Key funktioniert nicht"
+1. API-Key neu generieren
+2. Authorization Header prüfen: `Bearer YOUR_API_KEY`
+3. Token-Ablaufzeit prüfen
+
+### "Zeit wird nicht gespeichert"
+1. Gültige Zeit prüfen (innerhalb der Schwelle)
+2. Standort korrekt ausgewählt
+3. Internetverbindung prüfen
+4. Seite neu laden
+
+### "Achievements werden nicht vergeben"
+1. Tägliche Prüfung abwarten
+2. Bedingungen erfüllt prüfen
+3. System-Status prüfen
+4. Administrator kontaktieren
+
+## 📊 Statistiken und Monitoring
+
+### Wie rufe ich Statistiken ab?
+```bash
+# Admin-Statistiken
+curl -H "Authorization: Bearer ADMIN_TOKEN" http://localhost:3000/api/v1/admin/stats
+
+# Seiten-Statistiken
+curl -H "Authorization: Bearer ADMIN_TOKEN" http://localhost:3000/api/v1/admin/page-stats
+```
+
+### Wie überwache ich die Performance?
+```sql
+-- Langsamste Queries
+SELECT query, calls, total_time, mean_time
+FROM pg_stat_statements 
+ORDER BY mean_time DESC LIMIT 10;
+
+-- Index-Nutzung
+SELECT schemaname, tablename, indexname, idx_scan
+FROM pg_stat_user_indexes 
+ORDER BY idx_scan DESC;
+```
+
+### Wie prüfe ich die Datenbank-Größe?
+```sql
+-- Gesamtgröße
+SELECT pg_size_pretty(pg_database_size('ninjaserver'));
+
+-- Tabellen-Größen
+SELECT tablename, pg_size_pretty(pg_total_relation_size(tablename)) as size
+FROM pg_tables WHERE schemaname = 'public'
+ORDER BY pg_total_relation_size(tablename) DESC;
+```
+
+## 🔒 Sicherheit
+
+### Wie sichere ich das System?
+- Standardpasswörter ändern
+- HTTPS in der Produktion verwenden
+- Regelmäßige Backups
+- API-Keys regelmäßig rotieren
+- Firewall konfigurieren
+
+### Wie ändere ich das Admin-Passwort?
+```bash
+# Neuen Admin-Benutzer erstellen
+npm run create-user
+
+# Oder direkt in der Datenbank
+UPDATE adminusers SET password_hash = '$2b$10$...' WHERE username = 'admin';
+```
+
+### Wie deaktiviere ich einen API-Key?
+```sql
+UPDATE api_tokens SET is_active = false WHERE token = 'YOUR_TOKEN';
+```
+
+## 🌐 Deployment
+
+### Wie deploye ich in die Produktion?
+1. Server vorbereiten (Node.js, PostgreSQL)
+2. Code deployen
+3. Umgebungsvariablen setzen
+4. Datenbank initialisieren
+5. Nginx konfigurieren
+6. SSL-Zertifikat einrichten
+
+### Wie konfiguriere ich Nginx?
+```nginx
+server {
+    listen 80;
+    server_name ninja.reptilfpv.de;
+    
+    location / {
+        proxy_pass http://localhost:3000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_cache_bypass $http_upgrade;
+    }
+}
+```
+
+### Wie richte ich SSL ein?
+```bash
+# Let's Encrypt
+certbot --nginx -d ninja.reptilfpv.de
+```
+
+## 📱 Frontend
+
+### Wie integriere ich das System in meine Website?
+Verwenden Sie die REST API oder das Web-Interface. Siehe [API Referenz](API-Referenz) für Details.
+
+### Gibt es eine mobile App?
+Eine native mobile App ist geplant, aber noch nicht verfügbar. Das Web-Interface ist responsive und funktioniert auf allen Geräten.
+
+### Wie passe ich das Design an?
+Bearbeiten Sie die CSS-Dateien im `public/css/` Verzeichnis oder erstellen Sie ein eigenes Frontend mit der API.
+
+## 🔄 Updates und Wartung
+
+### Wie aktualisiere ich das System?
+```bash
+# Code aktualisieren
+git pull origin main
+
+# Abhängigkeiten aktualisieren
+npm install
+
+# Datenbank-Migrationen (falls vorhanden)
+npm run migrate
+
+# Server neu starten
+npm restart
+```
+
+### Wie führe ich Wartungsaufgaben durch?
+```sql
+-- Tabellen analysieren
+ANALYZE;
+
+-- Indizes neu aufbauen
+REINDEX DATABASE ninjaserver;
+
+-- Vakuum durchführen
+VACUUM ANALYZE;
+```
+
+### Wie lösche ich alte Daten?
+```sql
+-- Alte Zeiten löschen (älter als 1 Jahr)
+DELETE FROM times WHERE created_at < NOW() - INTERVAL '1 year';
+
+-- Alte Seitenaufrufe löschen (älter als 6 Monate)
+DELETE FROM page_views WHERE created_at < NOW() - INTERVAL '6 months';
+```
+
+## 📞 Support
+
+### Wo bekomme ich Hilfe?
+- 📖 Konsultieren Sie diese Dokumentation
+- 🔍 Schauen Sie in [Troubleshooting](Troubleshooting)
+- 📧 Kontaktieren Sie den Systemadministrator
+- 🐛 Melden Sie Bugs über das Issue-System
+
+### Wie melde ich einen Bug?
+1. Beschreiben Sie das Problem
+2. Fügen Sie Logs hinzu
+3. Geben Sie Schritte zur Reproduktion an
+4. Erwähnen Sie Ihre Systemkonfiguration
+
+### Wie schlage ich eine Verbesserung vor?
+1. Beschreiben Sie die gewünschte Funktion
+2. Erklären Sie den Nutzen
+3. Geben Sie Beispiele an
+4. Erwähnen Sie mögliche Implementierung
+
+---
+
+**Hinweis:** Diese FAQ wird regelmäßig aktualisiert. Bei Fragen, die hier nicht beantwortet werden, wenden Sie sich an den Support.
diff --git a/wiki/Home.md b/wiki/Home.md
new file mode 100644
index 0000000..e67f82a
--- /dev/null
+++ b/wiki/Home.md
@@ -0,0 +1,92 @@
+# 🏊‍♂️ Ninja Cross Parkour System Wiki
+
+Willkommen zum **Ninja Cross Parkour System** - einem interaktiven Zeitmessungssystem für das Schwimmbad!
+
+## 📋 Inhaltsverzeichnis
+
+- [🏠 Home](Home) - Diese Seite
+- [🚀 Schnellstart](Schnellstart) - Installation und erste Schritte
+- [📖 Benutzerhandbuch](Benutzerhandbuch) - Anleitung für Endbenutzer
+- [🔧 Entwicklerhandbuch](Entwicklerhandbuch) - Technische Dokumentation
+- [📡 API Referenz](API-Referenz) - Vollständige API-Dokumentation
+- [🏆 Achievement System](Achievement-System) - Gamification Features
+- [🗄️ Datenbank](Datenbank) - Schema und Struktur
+- [🔒 Sicherheit](Sicherheit) - Authentifizierung und Berechtigungen
+- [🚀 Deployment](Deployment) - Produktionsumgebung
+- [❓ FAQ](FAQ) - Häufige Fragen
+- [🐛 Troubleshooting](Troubleshooting) - Problembehandlung
+
+## 🎯 Was ist das Ninja Cross Parkour System?
+
+Das **Ninja Cross Parkour System** ist ein innovatives Zeitmessungssystem, das speziell für Schwimmbäder entwickelt wurde. Es ermöglicht es Besuchern, ihre Parkour-Zeiten zu messen, zu verfolgen und sich mit anderen zu vergleichen.
+
+### ✨ Hauptfunktionen
+
+- **⏱️ Präzise Zeitmessung** mit RFID-Technologie
+- **🗺️ Interaktive Karte** mit Standortverwaltung
+- **🏆 Achievement-System** mit 32 verschiedenen Erfolgen
+- **📊 Statistiken** und Bestenlisten
+- **🔔 Push-Benachrichtigungen** für neue Rekorde
+- **🌐 REST API** für Integrationen
+- **📱 Responsive Web-Interface** für alle Geräte
+
+### 🎮 Wie funktioniert es?
+
+1. **Spieler registrieren** sich über das Web-Interface
+2. **RFID-Karten** werden mit Spielerprofilen verknüpft
+3. **Zeitmessung** erfolgt automatisch beim Start/Stopp
+4. **Achievements** werden automatisch vergeben
+5. **Statistiken** werden in Echtzeit aktualisiert
+
+## 🏗️ System-Architektur
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Frontend      │    │   Backend       │    │   Database      │
+│   (Web UI)      │◄──►│   (Node.js)     │◄──►│   (PostgreSQL)  │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+         │                       │                       │
+         │                       │                       │
+         ▼                       ▼                       ▼
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   RFID Reader   │    │   API Endpoints │    │   Achievement   │
+│   (Hardware)    │    │   (REST)        │    │   System        │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+```
+
+## 🎯 Zielgruppen
+
+### 👥 Endbenutzer (Schwimmbadbesucher)
+- Zeitmessung und -verfolgung
+- Achievement-Sammlung
+- Statistiken und Fortschritt
+- Bestenlisten
+
+### 👨‍💼 Administratoren
+- Spieler- und Standortverwaltung
+- System-Monitoring
+- Statistiken und Berichte
+- API-Key Management
+
+### 👨‍💻 Entwickler
+- API-Integration
+- Custom Frontend
+- Datenbank-Zugriff
+- System-Erweiterungen
+
+## 🚀 Schnellstart
+
+Für einen schnellen Einstieg siehe [Schnellstart](Schnellstart).
+
+## 📞 Support
+
+Bei Fragen oder Problemen:
+- 📖 Konsultieren Sie die [FAQ](FAQ)
+- 🔍 Schauen Sie in [Troubleshooting](Troubleshooting)
+- 📧 Kontaktieren Sie den Systemadministrator
+
+---
+
+**Version:** 1.0.0  
+**Letzte Aktualisierung:** $(date)  
+**Autor:** Carsten Graf
diff --git a/wiki/Schnellstart.md b/wiki/Schnellstart.md
new file mode 100644
index 0000000..20d7241
--- /dev/null
+++ b/wiki/Schnellstart.md
@@ -0,0 +1,220 @@
+# 🚀 Schnellstart
+
+Diese Anleitung führt Sie durch die Installation und den ersten Start des Ninja Cross Parkour Systems.
+
+## 📋 Voraussetzungen
+
+### System-Anforderungen
+- **Node.js** v16 oder höher
+- **PostgreSQL** 12 oder höher
+- **npm** oder **yarn**
+- **Git** (für Installation)
+
+### Hardware-Anforderungen
+- **RFID-Reader** für Zeitmessung
+- **RFID-Karten** für Spieler
+- **Server** (Linux empfohlen)
+- **Netzwerk** für API-Zugriff
+
+## 🔧 Installation
+
+### 1. Repository klonen
+```bash
+git clone <repository-url>
+cd ninjaserver
+```
+
+### 2. Abhängigkeiten installieren
+```bash
+npm install
+```
+
+### 3. Umgebungsvariablen konfigurieren
+```bash
+cp .env.example .env
+```
+
+Bearbeiten Sie die `.env`-Datei:
+```env
+# Datenbank
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=ninjaserver
+DB_USER=your_username
+DB_PASSWORD=your_password
+
+# Server
+PORT=3000
+NODE_ENV=development
+
+# JWT Secret
+JWT_SECRET=your_jwt_secret_here
+
+# Supabase (optional)
+SUPABASE_URL=your_supabase_url
+SUPABASE_ANON_KEY=your_supabase_key
+```
+
+### 4. Datenbank initialisieren
+```bash
+npm run init-db
+```
+
+### 5. Standardbenutzer erstellen
+```bash
+npm run create-user
+```
+
+## 🚀 Server starten
+
+### Entwicklungsumgebung
+```bash
+npm run dev
+```
+Server läuft auf: `http://localhost:3000`
+
+### Produktionsumgebung
+```bash
+npm start
+```
+
+## 🔐 Erste Anmeldung
+
+### Web-Interface
+1. Öffnen Sie `http://localhost:3000`
+2. Melden Sie sich an mit:
+   - **Benutzername:** `admin`
+   - **Passwort:** `admin123`
+
+### API-Key generieren
+```bash
+curl -X POST http://localhost:3000/api/v1/web/generate-api-key \
+  -H "Content-Type: application/json" \
+  -d '{"description": "Mein erster API Key", "standorte": "Test"}'
+```
+
+## 🎮 Erste Schritte
+
+### 1. Standort erstellen
+```bash
+curl -X POST http://localhost:3000/api/v1/private/create-location \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "Test-Standort", "latitude": 48.1351, "longitude": 11.5820}'
+```
+
+### 2. Spieler erstellen
+```bash
+curl -X POST http://localhost:3000/api/v1/public/players \
+  -H "Content-Type: application/json" \
+  -d '{"firstname": "Max", "lastname": "Mustermann", "birthdate": "1990-01-01", "rfiduid": "AA:BB:CC:DD"}'
+```
+
+### 3. Zeit messen
+```bash
+curl -X POST http://localhost:3000/api/v1/private/create-time \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"player_id": "AA:BB:CC:DD", "location_id": "Test-Standort", "recorded_time": "01:23.456"}'
+```
+
+## 🧪 System testen
+
+### API-Test ausführen
+```bash
+# Test-Skript bearbeiten
+nano test-api.js
+
+# API_KEY in der Datei setzen
+node test-api.js
+```
+
+### Web-Interface testen
+1. Öffnen Sie `http://localhost:3000`
+2. Melden Sie sich an
+3. Erstellen Sie einen Standort
+4. Fügen Sie einen Spieler hinzu
+5. Messen Sie eine Zeit
+
+## 📊 Monitoring
+
+### Logs überwachen
+```bash
+# Server-Logs
+tail -f logs/server.log
+
+# Achievement-Logs
+tail -f /var/log/ninjaserver_achievements.log
+```
+
+### Datenbank-Status prüfen
+```sql
+-- Verbindung testen
+SELECT NOW();
+
+-- Tabellen anzeigen
+\dt
+
+-- Spieler zählen
+SELECT COUNT(*) FROM players;
+```
+
+## 🔧 Konfiguration
+
+### Standort-Schwellenwerte
+```bash
+curl -X PUT http://localhost:3000/api/v1/private/locations/{id}/threshold \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"threshold_seconds": 120}'
+```
+
+### Achievement-System aktivieren
+```bash
+# Tägliche Prüfung einrichten
+node scripts/setup_cron.js setup
+
+# Status prüfen
+node scripts/setup_cron.js status
+```
+
+## 🚨 Häufige Probleme
+
+### Port bereits belegt
+```bash
+# Port 3000 freigeben
+sudo lsof -ti:3000 | xargs kill -9
+
+# Oder anderen Port verwenden
+PORT=3001 npm start
+```
+
+### Datenbank-Verbindung fehlgeschlagen
+1. PostgreSQL-Service prüfen: `sudo systemctl status postgresql`
+2. Datenbank-Credentials in `.env` prüfen
+3. Firewall-Einstellungen prüfen
+
+### API-Key funktioniert nicht
+1. API-Key neu generieren
+2. Authorization Header prüfen: `Bearer YOUR_API_KEY`
+3. Token-Ablaufzeit prüfen
+
+## 📚 Nächste Schritte
+
+Nach der erfolgreichen Installation:
+
+1. 📖 Lesen Sie das [Benutzerhandbuch](Benutzerhandbuch)
+2. 🔧 Konsultieren Sie die [Entwicklerhandbuch](Entwicklerhandbuch)
+3. 📡 Schauen Sie in die [API Referenz](API-Referenz)
+4. 🏆 Entdecken Sie das [Achievement System](Achievement-System)
+
+## 🆘 Hilfe
+
+Bei Problemen:
+- 📖 [FAQ](FAQ) konsultieren
+- 🔍 [Troubleshooting](Troubleshooting) durchgehen
+- 📧 Support kontaktieren
+
+---
+
+**Tipp:** Verwenden Sie `npm run dev` für die Entwicklung - der Server startet automatisch neu bei Änderungen!
diff --git a/wiki/Sicherheit.md b/wiki/Sicherheit.md
new file mode 100644
index 0000000..be713bb
--- /dev/null
+++ b/wiki/Sicherheit.md
@@ -0,0 +1,621 @@
+# 🔒 Sicherheit
+
+Sicherheitsrichtlinien und Best Practices für das Ninja Cross Parkour System.
+
+## 📋 Inhaltsverzeichnis
+
+- [🛡️ Sicherheitsübersicht](#️-sicherheitsübersicht)
+- [🔐 Authentifizierung](#-authentifizierung)
+- [🔑 Autorisierung](#-autorisierung)
+- [🛡️ Datenverschlüsselung](#️-datenverschlüsselung)
+- [🌐 Netzwerksicherheit](#-netzwerksicherheit)
+- [🗄️ Datenbanksicherheit](#️-datenbanksicherheit)
+- [📱 API-Sicherheit](#-api-sicherheit)
+- [🔍 Monitoring](#-monitoring)
+- [🚨 Incident Response](#-incident-response)
+
+## 🛡️ Sicherheitsübersicht
+
+### Sicherheitsprinzipien
+- **Defense in Depth** - Mehrschichtige Sicherheit
+- **Least Privilege** - Minimale Berechtigungen
+- **Zero Trust** - Kein Vertrauen ohne Verifikation
+- **Security by Design** - Sicherheit von Anfang an
+
+### Bedrohungsmodell
+- **Externe Angriffe** - Unbefugter Zugriff von außen
+- **Interne Bedrohungen** - Missbrauch durch autorisierte Benutzer
+- **Datenlecks** - Unbefugte Offenlegung von Daten
+- **Service-Ausfälle** - Verfügbarkeitsprobleme
+
+## 🔐 Authentifizierung
+
+### Passwort-Sicherheit
+```javascript
+// Passwort-Hashing mit bcrypt
+const bcrypt = require('bcrypt');
+
+// Passwort hashen
+const saltRounds = 12;
+const hashedPassword = await bcrypt.hash(password, saltRounds);
+
+// Passwort verifizieren
+const isValid = await bcrypt.compare(password, hashedPassword);
+```
+
+### Passwort-Richtlinien
+- **Mindestlänge:** 12 Zeichen
+- **Komplexität:** Groß-/Kleinbuchstaben, Zahlen, Sonderzeichen
+- **Keine Wörterbuchwörter**
+- **Regelmäßige Rotation** (alle 90 Tage)
+
+### Multi-Faktor-Authentifizierung (MFA)
+```javascript
+// TOTP-Implementierung
+const speakeasy = require('speakeasy');
+
+// Secret generieren
+const secret = speakeasy.generateSecret({
+  name: 'Ninja Parkour',
+  account: 'admin@example.com'
+});
+
+// Token verifizieren
+const verified = speakeasy.totp.verify({
+  secret: secret.base32,
+  encoding: 'base32',
+  token: userToken,
+  window: 2
+});
+```
+
+### Session-Management
+```javascript
+// Sichere Session-Konfiguration
+app.use(session({
+  secret: process.env.SESSION_SECRET,
+  resave: false,
+  saveUninitialized: false,
+  cookie: {
+    secure: process.env.NODE_ENV === 'production',
+    httpOnly: true,
+    maxAge: 24 * 60 * 60 * 1000, // 24 Stunden
+    sameSite: 'strict'
+  }
+}));
+```
+
+## 🔑 Autorisierung
+
+### Rollenbasierte Zugriffskontrolle (RBAC)
+```javascript
+// Rollen definieren
+const ROLES = {
+  ADMIN: 'admin',
+  MODERATOR: 'moderator',
+  USER: 'user',
+  GUEST: 'guest'
+};
+
+// Berechtigungen definieren
+const PERMISSIONS = {
+  READ_PLAYERS: 'read:players',
+  WRITE_PLAYERS: 'write:players',
+  DELETE_PLAYERS: 'delete:players',
+  READ_TIMES: 'read:times',
+  WRITE_TIMES: 'write:times',
+  ADMIN_ACCESS: 'admin:access'
+};
+
+// Rollen-Berechtigungen
+const rolePermissions = {
+  [ROLES.ADMIN]: Object.values(PERMISSIONS),
+  [ROLES.MODERATOR]: [
+    PERMISSIONS.READ_PLAYERS,
+    PERMISSIONS.WRITE_PLAYERS,
+    PERMISSIONS.READ_TIMES,
+    PERMISSIONS.WRITE_TIMES
+  ],
+  [ROLES.USER]: [
+    PERMISSIONS.READ_PLAYERS,
+    PERMISSIONS.READ_TIMES
+  ]
+};
+```
+
+### API-Key-Management
+```javascript
+// API-Key generieren
+const generateAPIKey = () => {
+  return crypto.randomBytes(32).toString('hex');
+};
+
+// API-Key validieren
+const validateAPIKey = async (apiKey) => {
+  const token = await db.query(
+    'SELECT * FROM api_tokens WHERE token = $1 AND is_active = true',
+    [apiKey]
+  );
+  return token.rows.length > 0;
+};
+
+// Berechtigungen prüfen
+const checkPermission = (userRole, requiredPermission) => {
+  const userPermissions = rolePermissions[userRole] || [];
+  return userPermissions.includes(requiredPermission);
+};
+```
+
+### Middleware für Autorisierung
+```javascript
+// Authentifizierung prüfen
+const requireAuth = (req, res, next) => {
+  if (!req.session || !req.session.userId) {
+    return res.status(401).json({ error: 'Nicht authentifiziert' });
+  }
+  next();
+};
+
+// Rolle prüfen
+const requireRole = (role) => {
+  return (req, res, next) => {
+    if (req.session.role !== role) {
+      return res.status(403).json({ error: 'Keine Berechtigung' });
+    }
+    next();
+  };
+};
+
+// Berechtigung prüfen
+const requirePermission = (permission) => {
+  return (req, res, next) => {
+    const userRole = req.session.role;
+    if (!checkPermission(userRole, permission)) {
+      return res.status(403).json({ error: 'Keine Berechtigung' });
+    }
+    next();
+  };
+};
+```
+
+## 🛡️ Datenverschlüsselung
+
+### Verschlüsselung im Ruhezustand
+```javascript
+// Datenbank-Verschlüsselung
+const crypto = require('crypto');
+
+// Verschlüsselung
+const encrypt = (text, key) => {
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipher('aes-256-cbc', key);
+  let encrypted = cipher.update(text, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  return iv.toString('hex') + ':' + encrypted;
+};
+
+// Entschlüsselung
+const decrypt = (text, key) => {
+  const textParts = text.split(':');
+  const iv = Buffer.from(textParts.shift(), 'hex');
+  const encryptedText = textParts.join(':');
+  const decipher = crypto.createDecipher('aes-256-cbc', key);
+  let decrypted = decipher.update(encryptedText, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+  return decrypted;
+};
+```
+
+### Verschlüsselung in Bewegung
+```javascript
+// HTTPS-Konfiguration
+const https = require('https');
+const fs = require('fs');
+
+const options = {
+  key: fs.readFileSync('private-key.pem'),
+  cert: fs.readFileSync('certificate.pem'),
+  ciphers: [
+    'ECDHE-RSA-AES256-GCM-SHA384',
+    'ECDHE-RSA-AES128-GCM-SHA256',
+    'ECDHE-RSA-AES256-SHA384',
+    'ECDHE-RSA-AES128-SHA256'
+  ].join(':'),
+  honorCipherOrder: true
+};
+
+https.createServer(options, app).listen(443);
+```
+
+### Passwort-Verschlüsselung
+```javascript
+// Starke Passwort-Generierung
+const generatePassword = (length = 16) => {
+  const charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*';
+  let password = '';
+  for (let i = 0; i < length; i++) {
+    password += charset.charAt(Math.floor(Math.random() * charset.length));
+  }
+  return password;
+};
+
+// Passwort-Stärke prüfen
+const validatePassword = (password) => {
+  const minLength = 12;
+  const hasUpperCase = /[A-Z]/.test(password);
+  const hasLowerCase = /[a-z]/.test(password);
+  const hasNumbers = /\d/.test(password);
+  const hasSpecialChar = /[!@#$%^&*(),.?":{}|<>]/.test(password);
+  
+  return password.length >= minLength && 
+         hasUpperCase && 
+         hasLowerCase && 
+         hasNumbers && 
+         hasSpecialChar;
+};
+```
+
+## 🌐 Netzwerksicherheit
+
+### Firewall-Konfiguration
+```bash
+# UFW-Firewall (Ubuntu)
+sudo ufw enable
+sudo ufw default deny incoming
+sudo ufw default allow outgoing
+
+# Erlaubte Ports
+sudo ufw allow 22/tcp    # SSH
+sudo ufw allow 80/tcp    # HTTP
+sudo ufw allow 443/tcp   # HTTPS
+sudo ufw allow 3000/tcp  # App (nur intern)
+
+# Rate Limiting
+sudo ufw limit ssh
+```
+
+### DDoS-Schutz
+```javascript
+// Rate Limiting
+const rateLimit = require('express-rate-limit');
+
+const limiter = rateLimit({
+  windowMs: 15 * 60 * 1000, // 15 Minuten
+  max: 100, // Max 100 Requests pro IP
+  message: 'Zu viele Anfragen von dieser IP',
+  standardHeaders: true,
+  legacyHeaders: false
+});
+
+app.use('/api/', limiter);
+
+// Strikte Rate Limits für sensible Endpoints
+const strictLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 5,
+  message: 'Zu viele Login-Versuche'
+});
+
+app.use('/api/login', strictLimiter);
+```
+
+### CORS-Konfiguration
+```javascript
+// Sichere CORS-Einstellungen
+const cors = require('cors');
+
+const corsOptions = {
+  origin: (origin, callback) => {
+    const allowedOrigins = [
+      'https://ninja.reptilfpv.de',
+      'https://www.ninja.reptilfpv.de'
+    ];
+    
+    if (!origin || allowedOrigins.includes(origin)) {
+      callback(null, true);
+    } else {
+      callback(new Error('Nicht erlaubt durch CORS'));
+    }
+  },
+  credentials: true,
+  optionsSuccessStatus: 200
+};
+
+app.use(cors(corsOptions));
+```
+
+### SSL/TLS-Konfiguration
+```javascript
+// SSL-Redirect
+app.use((req, res, next) => {
+  if (req.header('x-forwarded-proto') !== 'https') {
+    res.redirect(`https://${req.header('host')}${req.url}`);
+  } else {
+    next();
+  }
+});
+
+// Security Headers
+const helmet = require('helmet');
+
+app.use(helmet({
+  contentSecurityPolicy: {
+    directives: {
+      defaultSrc: ["'self'"],
+      styleSrc: ["'self'", "'unsafe-inline'"],
+      scriptSrc: ["'self'"],
+      imgSrc: ["'self'", "data:", "https:"],
+      connectSrc: ["'self'"],
+      fontSrc: ["'self'"],
+      objectSrc: ["'none'"],
+      mediaSrc: ["'self'"],
+      frameSrc: ["'none'"]
+    }
+  },
+  hsts: {
+    maxAge: 31536000,
+    includeSubDomains: true,
+    preload: true
+  }
+}));
+```
+
+## 🗄️ Datenbanksicherheit
+
+### Verbindungssicherheit
+```javascript
+// Sichere Datenbankverbindung
+const dbConfig = {
+  host: process.env.DB_HOST,
+  port: process.env.DB_PORT,
+  database: process.env.DB_NAME,
+  user: process.env.DB_USER,
+  password: process.env.DB_PASSWORD,
+  ssl: {
+    rejectUnauthorized: true,
+    ca: fs.readFileSync('ca-certificate.pem')
+  },
+  connectionTimeoutMillis: 5000,
+  idleTimeoutMillis: 30000,
+  max: 20
+};
+```
+
+### SQL-Injection-Schutz
+```javascript
+// Parametrisierte Queries
+const getUser = async (userId) => {
+  const query = 'SELECT * FROM players WHERE id = $1';
+  const values = [userId];
+  const result = await db.query(query, values);
+  return result.rows[0];
+};
+
+// Input-Validierung
+const validateInput = (input) => {
+  if (typeof input !== 'string') {
+    throw new Error('Invalid input type');
+  }
+  
+  // SQL-Injection-Patterns erkennen
+  const sqlPatterns = [
+    /(\b(SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|EXEC|UNION|SCRIPT)\b)/gi,
+    /(\b(OR|AND)\s+\d+\s*=\s*\d+)/gi,
+    /(\b(OR|AND)\s+['"]\s*=\s*['"])/gi
+  ];
+  
+  for (const pattern of sqlPatterns) {
+    if (pattern.test(input)) {
+      throw new Error('Potential SQL injection detected');
+    }
+  }
+  
+  return input;
+};
+```
+
+### Datenbank-Berechtigungen
+```sql
+-- Benutzer mit minimalen Rechten erstellen
+CREATE USER ninja_app WITH PASSWORD 'secure_password';
+
+-- Nur notwendige Berechtigungen gewähren
+GRANT SELECT, INSERT, UPDATE, DELETE ON players TO ninja_app;
+GRANT SELECT, INSERT, UPDATE, DELETE ON times TO ninja_app;
+GRANT SELECT, INSERT, UPDATE, DELETE ON locations TO ninja_app;
+GRANT SELECT, INSERT, UPDATE, DELETE ON achievements TO ninja_app;
+GRANT SELECT, INSERT, UPDATE, DELETE ON player_achievements TO ninja_app;
+
+-- Keine Admin-Rechte
+REVOKE ALL ON SCHEMA public FROM ninja_app;
+```
+
+## 📱 API-Sicherheit
+
+### Input-Validierung
+```javascript
+// Joi-Schema für Validierung
+const Joi = require('joi');
+
+const playerSchema = Joi.object({
+  firstname: Joi.string().min(2).max(50).required(),
+  lastname: Joi.string().min(2).max(50).required(),
+  birthdate: Joi.date().max('now').required(),
+  rfiduid: Joi.string().pattern(/^[A-F0-9:]{11}$/).optional()
+});
+
+const validatePlayer = (req, res, next) => {
+  const { error } = playerSchema.validate(req.body);
+  if (error) {
+    return res.status(400).json({ error: error.details[0].message });
+  }
+  next();
+};
+```
+
+### API-Versionierung
+```javascript
+// API-Versionierung
+app.use('/api/v1', v1Routes);
+app.use('/api/v2', v2Routes);
+
+// Deprecation-Warnungen
+app.use('/api/v1', (req, res, next) => {
+  res.set('X-API-Version', '1.0.0');
+  res.set('X-API-Deprecated', 'false');
+  next();
+});
+```
+
+### Request-Logging
+```javascript
+// Sicherheitsrelevante Logs
+const securityLogger = winston.createLogger({
+  level: 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  transports: [
+    new winston.transports.File({ filename: 'logs/security.log' })
+  ]
+});
+
+// Login-Versuche loggen
+app.post('/api/login', (req, res) => {
+  const { username, ip } = req.body;
+  securityLogger.info('Login attempt', { username, ip, timestamp: new Date() });
+  // ... Login-Logik
+});
+```
+
+## 🔍 Monitoring
+
+### Sicherheits-Monitoring
+```javascript
+// Anomalie-Erkennung
+const detectAnomalies = (req, res, next) => {
+  const ip = req.ip;
+  const userAgent = req.get('User-Agent');
+  
+  // Verdächtige Patterns erkennen
+  const suspiciousPatterns = [
+    /sqlmap/i,
+    /nikto/i,
+    /nmap/i,
+    /masscan/i
+  ];
+  
+  for (const pattern of suspiciousPatterns) {
+    if (pattern.test(userAgent)) {
+      securityLogger.warn('Suspicious user agent detected', { ip, userAgent });
+      return res.status(403).json({ error: 'Request blocked' });
+    }
+  }
+  
+  next();
+};
+```
+
+### Log-Analyse
+```bash
+# Sicherheitsrelevante Logs analysieren
+grep "ERROR\|WARN\|SECURITY" logs/server.log | tail -100
+
+# Failed Login-Versuche
+grep "Login attempt" logs/security.log | grep "failed"
+
+# Verdächtige Aktivitäten
+grep "suspicious\|anomaly\|attack" logs/security.log
+```
+
+### Alerting
+```javascript
+// E-Mail-Benachrichtigungen
+const nodemailer = require('nodemailer');
+
+const transporter = nodemailer.createTransporter({
+  host: 'smtp.gmail.com',
+  port: 587,
+  secure: false,
+  auth: {
+    user: process.env.EMAIL_USER,
+    pass: process.env.EMAIL_PASS
+  }
+});
+
+const sendSecurityAlert = async (message) => {
+  await transporter.sendMail({
+    from: process.env.EMAIL_USER,
+    to: process.env.ADMIN_EMAIL,
+    subject: 'Security Alert - Ninja Parkour',
+    text: message
+  });
+};
+```
+
+## 🚨 Incident Response
+
+### Incident-Response-Plan
+1. **Erkennung** - Monitoring und Alerts
+2. **Bewertung** - Schweregrad bestimmen
+3. **Eindämmung** - Schaden begrenzen
+4. **Eliminierung** - Bedrohung entfernen
+5. **Wiederherstellung** - System reparieren
+6. **Lektionen** - Aus Fehlern lernen
+
+### Notfall-Kontakte
+- **Systemadministrator:** +49 123 456 789
+- **Sicherheitsbeauftragter:** security@ninjaparkour.de
+- **Management:** management@ninjaparkour.de
+
+### Backup-Strategie
+```bash
+# Tägliche Backups
+pg_dump -h localhost -U username -d ninjaserver | gzip > backup_$(date +%Y%m%d).sql.gz
+
+# Wöchentliche Vollständige Backups
+tar -czf full_backup_$(date +%Y%m%d).tar.gz /var/lib/postgresql/data/
+
+# Backup-Verifizierung
+psql -d ninjaserver < backup_$(date +%Y%m%d).sql
+```
+
+### Recovery-Prozeduren
+```bash
+# System wiederherstellen
+sudo systemctl stop ninjaserver
+psql -d ninjaserver < latest_backup.sql
+sudo systemctl start ninjaserver
+
+# Datenbank reparieren
+psql -d ninjaserver -c "VACUUM FULL;"
+psql -d ninjaserver -c "REINDEX DATABASE ninjaserver;"
+```
+
+## 🔧 Sicherheits-Checkliste
+
+### Regelmäßige Überprüfungen
+- [ ] Passwörter geändert (alle 90 Tage)
+- [ ] API-Keys rotiert (alle 180 Tage)
+- [ ] SSL-Zertifikate gültig
+- [ ] Sicherheits-Updates installiert
+- [ ] Logs überprüft
+- [ ] Backups getestet
+- [ ] Penetrationstests durchgeführt
+
+### Wöchentliche Aufgaben
+- [ ] Sicherheits-Logs analysiert
+- [ ] System-Updates geprüft
+- [ ] Backup-Status überprüft
+- [ ] Performance-Metriken analysiert
+
+### Monatliche Aufgaben
+- [ ] Sicherheits-Audit durchgeführt
+- [ ] Berechtigungen überprüft
+- [ ] Incident-Response-Plan getestet
+- [ ] Sicherheitsschulungen durchgeführt
+
+---
+
+**Wichtig:** Diese Sicherheitsrichtlinien müssen regelmäßig überprüft und aktualisiert werden. Bei Sicherheitsvorfällen wenden Sie sich sofort an den Sicherheitsbeauftragten.
diff --git a/wiki/Troubleshooting.md b/wiki/Troubleshooting.md
new file mode 100644
index 0000000..33e0fcd
--- /dev/null
+++ b/wiki/Troubleshooting.md
@@ -0,0 +1,687 @@
+# 🐛 Troubleshooting
+
+Problembehandlung und Lösungen für häufige Probleme im Ninja Cross Parkour System.
+
+## 📋 Inhaltsverzeichnis
+
+- [🚨 Kritische Probleme](#-kritische-probleme)
+- [🔧 Installation](#-installation)
+- [🗄️ Datenbank](#️-datenbank)
+- [🌐 API](#-api)
+- [🏆 Achievements](#-achievements)
+- [📊 Performance](#-performance)
+- [🔒 Sicherheit](#-sicherheit)
+- [📱 Frontend](#-frontend)
+
+## 🚨 Kritische Probleme
+
+### Server startet nicht
+
+**Symptome:**
+- `npm start` schlägt fehl
+- Port-Fehler
+- Abhängigkeitsfehler
+
+**Lösungen:**
+```bash
+# Port freigeben
+sudo lsof -ti:3000 | xargs kill -9
+
+# Abhängigkeiten neu installieren
+rm -rf node_modules package-lock.json
+npm install
+
+# Anderen Port verwenden
+PORT=3001 npm start
+
+# Logs prüfen
+tail -f logs/server.log
+```
+
+### Datenbank-Verbindung fehlgeschlagen
+
+**Symptome:**
+- `ECONNREFUSED` Fehler
+- `database connection failed`
+- Timeout-Fehler
+
+**Lösungen:**
+```bash
+# PostgreSQL-Status prüfen
+sudo systemctl status postgresql
+
+# PostgreSQL starten
+sudo systemctl start postgresql
+
+# Verbindung testen
+psql -h localhost -U username -d ninjaserver
+
+# .env-Datei prüfen
+cat .env | grep DB_
+```
+
+### API antwortet nicht
+
+**Symptome:**
+- 500 Internal Server Error
+- Timeout-Fehler
+- Leere Antworten
+
+**Lösungen:**
+```bash
+# Server-Status prüfen
+curl http://localhost:3000/health
+
+# Logs analysieren
+tail -f logs/server.log
+
+# Datenbank-Verbindung prüfen
+psql -d ninjaserver -c "SELECT NOW();"
+
+# Speicher prüfen
+free -h
+df -h
+```
+
+## 🔧 Installation
+
+### Node.js-Version inkompatibel
+
+**Symptom:**
+```
+Error: Node.js version 14.x is not supported. Please use Node.js 16 or higher.
+```
+
+**Lösung:**
+```bash
+# Node.js-Version prüfen
+node --version
+
+# Node.js aktualisieren (Ubuntu/Debian)
+curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
+sudo apt-get install -y nodejs
+
+# Node.js aktualisieren (macOS)
+brew install node@18
+
+# Node.js aktualisieren (Windows)
+# Download von https://nodejs.org/
+```
+
+### npm install schlägt fehl
+
+**Symptome:**
+- Permission denied
+- ENOENT Fehler
+- Network timeout
+
+**Lösungen:**
+```bash
+# Berechtigungen prüfen
+sudo chown -R $(whoami) ~/.npm
+
+# Cache leeren
+npm cache clean --force
+
+# Registry wechseln
+npm config set registry https://registry.npmjs.org/
+
+# Mit sudo installieren (nicht empfohlen)
+sudo npm install
+```
+
+### PostgreSQL nicht installiert
+
+**Symptom:**
+```
+Error: connect ECONNREFUSED 127.0.0.1:5432
+```
+
+**Lösung:**
+```bash
+# PostgreSQL installieren (Ubuntu/Debian)
+sudo apt update
+sudo apt install postgresql postgresql-contrib
+
+# PostgreSQL starten
+sudo systemctl start postgresql
+sudo systemctl enable postgresql
+
+# Benutzer erstellen
+sudo -u postgres createuser --interactive
+sudo -u postgres createdb ninjaserver
+```
+
+### Umgebungsvariablen fehlen
+
+**Symptom:**
+```
+Error: Missing required environment variable: DB_HOST
+```
+
+**Lösung:**
+```bash
+# .env-Datei erstellen
+cp .env.example .env
+
+# .env-Datei bearbeiten
+nano .env
+
+# Beispiel-Inhalt:
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=ninjaserver
+DB_USER=username
+DB_PASSWORD=password
+JWT_SECRET=your-secret-key
+```
+
+## 🗄️ Datenbank
+
+### Datenbank existiert nicht
+
+**Symptom:**
+```
+Error: database "ninjaserver" does not exist
+```
+
+**Lösung:**
+```bash
+# Datenbank erstellen
+sudo -u postgres createdb ninjaserver
+
+# Oder mit psql
+psql -U postgres -c "CREATE DATABASE ninjaserver;"
+```
+
+### Tabellen fehlen
+
+**Symptom:**
+```
+Error: relation "players" does not exist
+```
+
+**Lösung:**
+```bash
+# Datenbank initialisieren
+npm run init-db
+
+# Oder manuell
+psql -d ninjaserver -f scripts/init-db.js
+```
+
+### Verbindungslimit erreicht
+
+**Symptom:**
+```
+Error: too many connections
+```
+
+**Lösung:**
+```sql
+-- Aktive Verbindungen prüfen
+SELECT count(*) FROM pg_stat_activity;
+
+-- Verbindungen beenden
+SELECT pg_terminate_backend(pid) 
+FROM pg_stat_activity 
+WHERE state = 'idle' AND query_start < NOW() - INTERVAL '5 minutes';
+
+-- Verbindungslimit erhöhen
+ALTER SYSTEM SET max_connections = 200;
+SELECT pg_reload_conf();
+```
+
+### Datenbank-Corruption
+
+**Symptom:**
+```
+Error: database is not accepting commands
+```
+
+**Lösung:**
+```bash
+# Datenbank reparieren
+pg_ctl stop
+pg_ctl start -D /var/lib/postgresql/data
+
+# Vakuum durchführen
+psql -d ninjaserver -c "VACUUM FULL;"
+
+# Backup wiederherstellen
+psql -d ninjaserver < backup.sql
+```
+
+## 🌐 API
+
+### 401 Unauthorized
+
+**Symptom:**
+```
+{"success": false, "message": "API-Key erforderlich"}
+```
+
+**Lösung:**
+```bash
+# API-Key generieren
+curl -X POST http://localhost:3000/api/v1/web/generate-api-key \
+  -H "Content-Type: application/json" \
+  -d '{"description": "Test Key"}'
+
+# API-Key verwenden
+curl -H "Authorization: Bearer YOUR_API_KEY" \
+  http://localhost:3000/api/v1/private/locations
+```
+
+### 403 Forbidden
+
+**Symptom:**
+```
+{"success": false, "message": "Keine Berechtigung"}
+```
+
+**Lösung:**
+```bash
+# Admin-Token verwenden
+curl -H "Authorization: Bearer ADMIN_TOKEN" \
+  http://localhost:3000/api/v1/admin/players
+
+# Oder API-Key mit Admin-Rechten generieren
+```
+
+### 404 Not Found
+
+**Symptom:**
+```
+{"success": false, "message": "Ressource nicht gefunden"}
+```
+
+**Lösung:**
+```bash
+# Korrekte URL verwenden
+curl http://localhost:3000/api/v1/public/locations
+
+# Endpoint-Liste prüfen
+curl http://localhost:3000/api-docs
+```
+
+### 500 Internal Server Error
+
+**Symptom:**
+```
+{"success": false, "message": "Internal Server Error"}
+```
+
+**Lösung:**
+```bash
+# Logs prüfen
+tail -f logs/server.log
+
+# Datenbank-Verbindung prüfen
+psql -d ninjaserver -c "SELECT NOW();"
+
+# Server neu starten
+npm restart
+```
+
+### CORS-Fehler
+
+**Symptom:**
+```
+Access to fetch at 'http://localhost:3000/api' from origin 'http://localhost:8080' has been blocked by CORS policy
+```
+
+**Lösung:**
+```javascript
+// CORS-Middleware konfigurieren
+app.use(cors({
+  origin: ['http://localhost:8080', 'https://yourdomain.com'],
+  credentials: true
+}));
+```
+
+## 🏆 Achievements
+
+### Achievements werden nicht vergeben
+
+**Symptom:**
+- Spieler erfüllt Bedingungen, aber erhält kein Achievement
+- Tägliche Prüfung läuft nicht
+
+**Lösung:**
+```bash
+# Tägliche Prüfung manuell ausführen
+node scripts/daily_achievements.js
+
+# Cron-Job prüfen
+node scripts/setup_cron.js status
+
+# Cron-Job einrichten
+node scripts/setup_cron.js setup
+
+# Logs prüfen
+tail -f /var/log/ninjaserver_achievements.log
+```
+
+### Achievement-Daten korrupt
+
+**Symptom:**
+- Achievements werden mehrfach vergeben
+- Falsche Fortschrittswerte
+
+**Lösung:**
+```sql
+-- Doppelte Achievements entfernen
+DELETE FROM player_achievements 
+WHERE id NOT IN (
+  SELECT MIN(id) 
+  FROM player_achievements 
+  GROUP BY player_id, achievement_id
+);
+
+-- Fortschritt zurücksetzen
+UPDATE player_achievements 
+SET progress = 0, is_completed = false 
+WHERE is_completed = false;
+```
+
+### Tägliche Prüfung schlägt fehl
+
+**Symptom:**
+```
+Error: Daily achievement check failed
+```
+
+**Lösung:**
+```bash
+# Logs analysieren
+grep "ERROR" /var/log/ninjaserver_achievements.log
+
+# Datenbank-Verbindung prüfen
+psql -d ninjaserver -c "SELECT NOW();"
+
+# Berechtigungen prüfen
+ls -la /var/log/ninjaserver_achievements.log
+
+# Script manuell ausführen
+node scripts/daily_achievements.js
+```
+
+## 📊 Performance
+
+### Langsame API-Antworten
+
+**Symptom:**
+- API-Antworten dauern > 5 Sekunden
+- Timeout-Fehler
+
+**Lösung:**
+```sql
+-- Indizes prüfen
+SELECT schemaname, tablename, indexname, idx_scan
+FROM pg_stat_user_indexes 
+ORDER BY idx_scan DESC;
+
+-- Langsame Queries identifizieren
+SELECT query, calls, total_time, mean_time
+FROM pg_stat_statements 
+ORDER BY mean_time DESC LIMIT 10;
+
+-- Indizes hinzufügen
+CREATE INDEX CONCURRENTLY idx_times_player_created 
+ON times(player_id, created_at DESC);
+```
+
+### Hohe CPU-Last
+
+**Symptom:**
+- Server verbraucht > 80% CPU
+- Langsame Antwortzeiten
+
+**Lösung:**
+```bash
+# Prozesse prüfen
+top -p $(pgrep node)
+
+# Speicher prüfen
+free -h
+
+# Datenbank-Verbindungen prüfen
+psql -d ninjaserver -c "SELECT count(*) FROM pg_stat_activity;"
+
+# Vakuum durchführen
+psql -d ninjaserver -c "VACUUM ANALYZE;"
+```
+
+### Speicher-Leaks
+
+**Symptom:**
+- Speicherverbrauch steigt kontinuierlich
+- Server stürzt ab
+
+**Lösung:**
+```bash
+# Speicher-Usage prüfen
+ps aux | grep node
+
+# Server neu starten
+pm2 restart ninjaserver
+
+# Oder mit systemd
+sudo systemctl restart ninjaserver
+```
+
+## 🔒 Sicherheit
+
+### Schwache Passwörter
+
+**Symptom:**
+- Standardpasswörter in Produktion
+- Sicherheitswarnungen
+
+**Lösung:**
+```bash
+# Admin-Passwort ändern
+npm run create-user
+
+# Oder direkt in der Datenbank
+psql -d ninjaserver -c "UPDATE adminusers SET password_hash = '\$2b\$10\$...' WHERE username = 'admin';"
+```
+
+### API-Key kompromittiert
+
+**Symptom:**
+- Unerwartete API-Aufrufe
+- Unbekannte Aktivitäten
+
+**Lösung:**
+```sql
+-- API-Key deaktivieren
+UPDATE api_tokens SET is_active = false WHERE token = 'COMPROMISED_TOKEN';
+
+-- Neuen API-Key generieren
+-- (über API oder direkt in der Datenbank)
+```
+
+### SQL-Injection
+
+**Symptom:**
+- Unerwartete Datenbank-Abfragen
+- Fehlerhafte API-Antworten
+
+**Lösung:**
+```javascript
+// Parametrisierte Queries verwenden
+const result = await db.query(
+  'SELECT * FROM players WHERE id = $1',
+  [playerId]
+);
+
+// Input-Validierung
+if (!isValidUUID(playerId)) {
+  throw new Error('Invalid player ID');
+}
+```
+
+## 📱 Frontend
+
+### JavaScript-Fehler
+
+**Symptom:**
+- Konsole zeigt Fehler
+- Funktionen funktionieren nicht
+
+**Lösung:**
+```javascript
+// Browser-Konsole prüfen
+console.error('Error details:', error);
+
+// API-Verbindung testen
+fetch('/api/v1/public/locations')
+  .then(response => response.json())
+  .then(data => console.log(data))
+  .catch(error => console.error('API Error:', error));
+```
+
+### CORS-Probleme
+
+**Symptom:**
+```
+Access to fetch at 'http://localhost:3000/api' from origin 'http://localhost:8080' has been blocked by CORS policy
+```
+
+**Lösung:**
+```javascript
+// CORS-Header setzen
+fetch('/api/v1/public/locations', {
+  method: 'GET',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  mode: 'cors'
+});
+```
+
+### Session-Probleme
+
+**Symptom:**
+- Login funktioniert nicht
+- Session wird nicht gespeichert
+
+**Lösung:**
+```javascript
+// Session-Cookie prüfen
+document.cookie
+
+// Login-Request prüfen
+fetch('/api/v1/public/login', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  credentials: 'include',
+  body: JSON.stringify({
+    username: 'admin',
+    password: 'admin123'
+  })
+});
+```
+
+## 🔧 Allgemeine Lösungen
+
+### Logs analysieren
+
+```bash
+# Server-Logs
+tail -f logs/server.log
+
+# Error-Logs
+grep "ERROR" logs/server.log
+
+# Achievement-Logs
+tail -f /var/log/ninjaserver_achievements.log
+
+# System-Logs
+journalctl -u ninjaserver -f
+```
+
+### System-Status prüfen
+
+```bash
+# Server-Status
+curl http://localhost:3000/health
+
+# Datenbank-Status
+psql -d ninjaserver -c "SELECT NOW();"
+
+# Speicher-Status
+free -h
+df -h
+
+# Prozess-Status
+ps aux | grep node
+```
+
+### Backup wiederherstellen
+
+```bash
+# Vollständiges Backup
+psql -d ninjaserver < backup.sql
+
+# Nur Daten
+psql -d ninjaserver < data_backup.sql
+
+# Nur Schema
+psql -d ninjaserver < schema_backup.sql
+```
+
+### System neu starten
+
+```bash
+# Mit npm
+npm restart
+
+# Mit pm2
+pm2 restart ninjaserver
+
+# Mit systemd
+sudo systemctl restart ninjaserver
+
+# Mit Docker
+docker restart ninjaserver
+```
+
+## 📞 Support kontaktieren
+
+Wenn diese Lösungen nicht helfen:
+
+1. **Logs sammeln:**
+   ```bash
+   # Alle relevanten Logs
+   tail -n 100 logs/server.log > error_log.txt
+   tail -n 100 /var/log/ninjaserver_achievements.log >> error_log.txt
+   ```
+
+2. **System-Info sammeln:**
+   ```bash
+   # System-Informationen
+   uname -a > system_info.txt
+   node --version >> system_info.txt
+   npm --version >> system_info.txt
+   psql --version >> system_info.txt
+   ```
+
+3. **Problem beschreiben:**
+   - Was passiert ist
+   - Wann es passiert ist
+   - Welche Schritte Sie unternommen haben
+   - Fehlermeldungen
+
+4. **Support kontaktieren:**
+   - E-Mail: support@ninjaparkour.de
+   - Issue-System verwenden
+   - Logs und System-Info anhängen
+
+---
+
+**Hinweis:** Diese Anleitung wird regelmäßig aktualisiert. Bei neuen Problemen wenden Sie sich an den Support.