fix: Gitea Traefik routing and connection pool optimization

- Remove middleware reference from Gitea Traefik labels (caused routing issues)
- Optimize Gitea connection pool settings (MAX_IDLE_CONNS=30, authentication_timeout=180s)
- Add explicit service reference in Traefik labels
- Fix intermittent 504 timeouts by improving PostgreSQL connection handling

Fixes Gitea unreachability via git.michaelschiemer.de

docs/ERROR-RENDERER-IMPROVEMENTS-PLAN.md

@@ -0,0 +1,274 @@
+# ErrorRenderer Verbesserungen - Template Syntax, Reflection, Optimierungen
+
+## Problem-Analyse
+
+### 1. Template-Syntax Inkonsistenz
+**Aktuell**: Templates verwenden `{variable}` Syntax
+**Erwartet**: Template-System verwendet PHP-Syntax `{{ $variable }}` (mit Dollar-Sign)
+**Betroffen**: Alle Error-Templates (`error.view.php`, `404.view.php`, `500.view.php`)
+
+### 2. Reflection in ErrorKernel
+**Problem**: `createHttpResponse()` verwendet Reflection, um auf private `engine` Property zuzugreifen
+**Location**: `src/Framework/ExceptionHandling/ErrorKernel.php:160-163`
+**Lösung**: Factory-Methode für Renderer mit geändertem Debug-Mode hinzufügen
+
+### 3. ConsoleOutput unnötig für HTTP-Context
+**Problem**: ConsoleOutput wird für alle Kontexte erstellt, auch wenn nicht benötigt
+**Location**: `src/Framework/ExceptionHandling/ExceptionHandlingInitializer.php:37-39`
+**Lösung**: Lazy creation nur bei CLI-Context
+
+### 4. If-Syntax nicht kompatibel
+**Aktuell**: Templates verwenden `{if variable}` und `{/if}` Syntax
+**Erwartet**: HTML-Attribut-Syntax `<div if="$variable">` (mit Dollar-Sign für PHP-Syntax)
+**Betroffen**: Alle Error-Templates mit bedingten Blöcken
+
+### 5. Fehlerbehandlung bei Template-Rendering
+**Problem**: Fallback-Handling könnte robuster sein
+**Location**: `src/Framework/ExceptionHandling/Renderers/ResponseErrorRenderer.php:143-169`
+
+## Lösungsvorschlag
+
+### Phase 1: Template-Syntax korrigieren (PHP-Syntax)
+
+#### 1.1 Variable-Syntax korrigieren (PHP-Syntax mit Dollar)
+**Änderungen** (alle mit Dollar-Sign):
+- `{title}` → `{{ $title }}`
+- `{message}` → `{{ $message }}`
+- `{exceptionClass}` → `{{ $exceptionClass }}`
+- `{debug.file}` → `{{ $debug['file'] }}` oder `{{ $data['debug']['file'] }}`
+- `{debug.line}` → `{{ $debug['line'] }}` oder `{{ $data['debug']['line'] }}`
+- `{debug.trace}` → `{{ $debug['trace'] }}` oder `{{ $data['debug']['trace'] }}`
+- `{context.operation}` → `{{ $context['operation'] }}` oder `{{ $data['context']['operation'] }}`
+- `{context.component}` → `{{ $context['component'] }}` oder `{{ $data['context']['component'] }}`
+- `{context.request_id}` → `{{ $context['request_id'] }}` oder `{{ $data['context']['request_id'] }}`
+- `{context.occurred_at}` → `{{ $context['occurred_at'] }}` oder `{{ $data['context']['occurred_at'] }}`
+
+**Hinweis**: Da `$data` im RenderContext als Array übergeben wird, sollte Array-Syntax verwendet werden:
+- `{{ $data['title'] }}`
+- `{{ $data['debug']['file'] }}`
+- `{{ $data['context']['operation'] }}`
+
+**Dateien**:
+- `resources/views/errors/error.view.php`
+- `resources/views/errors/404.view.php`
+- `resources/views/errors/500.view.php`
+
+#### 1.2 If-Syntax auf HTML-Attribute umstellen (mit Dollar-Syntax)
+**Änderungen**:
+- `{if isDebugMode}...{/if}` → `<div if="$isDebugMode">...</div>` oder `<style if="$isDebugMode">...</style>`
+- `{if debug}...{/if}` → `<div if="$debug">...</div>`
+- `{if context}...{/if}` → `<div if="$context">...</div>`
+- `{if debug.trace}...{/if}` → `<div if="$debug['trace']">...</div>`
+
+**Beispiel Transformation**:
+```html
+<!-- Alt -->
+{if isDebugMode}
+<div class="debug-info">{{message}}</div>
+{/if}
+
+<!-- Neu -->
+<div class="debug-info" if="$isDebugMode">{{ $message }}</div>
+```
+
+**Hinweis**: If-Bedingungen verwenden auch Dollar-Syntax für Variablen: `if="$isDebugMode"`
+
+**Dateien**:
+- `resources/views/errors/error.view.php`
+- `resources/views/errors/500.view.php`
+
+### Phase 2: Reflection entfernen
+
+#### 2.1 ErrorRendererFactory erweitern
+**Neue Methode hinzufügen**:
+```php
+public function createHttpRenderer(?bool $debugMode = null): ResponseErrorRenderer
+{
+    $debugMode = $debugMode ?? $this->isDebugMode;
+    return new ResponseErrorRenderer($this->engine, $debugMode);
+}
+```
+
+**Datei**: `src/Framework/ExceptionHandling/ErrorRendererFactory.php`
+
+#### 2.2 ErrorKernel anpassen
+**Reflection-Code ersetzen**:
+```php
+// Alt (Reflection)
+$reflection = new \ReflectionClass($this->rendererFactory);
+$engineProperty = $reflection->getProperty('engine');
+$engineProperty->setAccessible(true);
+$engine = $engineProperty->getValue($this->rendererFactory);
+$renderer = new ResponseErrorRenderer($engine, $debugMode);
+
+// Neu (Factory-Methode)
+if ($renderer instanceof ResponseErrorRenderer && $debugMode !== $this->isDebugMode) {
+    $renderer = $this->rendererFactory->createHttpRenderer($debugMode);
+}
+```
+
+**Datei**: `src/Framework/ExceptionHandling/ErrorKernel.php`
+
+### Phase 3: ConsoleOutput optimieren
+
+#### 3.1 ExceptionHandlingInitializer anpassen
+**Lazy Creation für ConsoleOutput**:
+```php
+// Alt: Immer erstellen
+$consoleOutput = $container->has(ConsoleOutput::class)
+    ? $container->get(ConsoleOutput::class)
+    : new ConsoleOutput();
+
+// Neu: Nur bei CLI-Context erstellen
+$consoleOutput = $executionContext->isCli()
+    ? ($container->has(ConsoleOutput::class) ? $container->get(ConsoleOutput::class) : new ConsoleOutput())
+    : null;
+```
+
+**Anpassung in ErrorRendererFactory-Binding**:
+- Factory sollte ConsoleOutput nur bei CLI-Context benötigen
+- Für HTTP-Context kann `null` übergeben werden (wird nicht verwendet)
+
+**Datei**: `src/Framework/ExceptionHandling/ExceptionHandlingInitializer.php`
+
+### Phase 4: Fehlerbehandlung verbessern
+
+#### 4.1 Template-Rendering Error Handling
+**Verbesserungen**:
+- Logging bei Template-Fehlern hinzufügen
+- Spezifischere Fehlermeldungen
+- Fallback sollte alle notwendigen Daten enthalten
+
+**Datei**: `src/Framework/ExceptionHandling/Renderers/ResponseErrorRenderer.php`
+
+#### 4.2 Fallback HTML verbessern
+**Sicherstellen, dass Fallback**:
+- Alle Template-Variablen korrekt ersetzt
+- HTML-Encoding korrekt anwendet
+- Debug-Informationen nur bei Debug-Mode zeigt
+
+**Datei**: `src/Framework/ExceptionHandling/Renderers/ResponseErrorRenderer.php`
+
+## Implementierungs-Plan
+
+### Schritt 1: Template-Syntax korrigieren (PHP-Syntax)
+1. **error.view.php** anpassen
+   - Variable-Syntax: `{variable}` → `{{ $variable }}` (PHP-Syntax mit Dollar)
+   - Array-Zugriff: `{debug.file}` → `{{ $debug['file'] }}` oder `{{ $data['debug']['file'] }}`
+   - If-Syntax: `{if}...{/if}` → HTML-Attribute `if="$variable"` (mit Dollar)
+   - Style-Tags: Conditional Styles mit `if="$isDebugMode"` Attribut
+
+2. **404.view.php** anpassen
+   - Variable-Syntax korrigieren (falls vorhanden)
+   - PHP-Syntax: `{{ $variable }}`
+
+3. **500.view.php** anpassen
+   - Variable-Syntax: `{variable}` → `{{ $variable }}` (PHP-Syntax mit Dollar)
+   - Array-Zugriff für verschachtelte Daten
+   - If-Syntax: `{if}...{/if}` → HTML-Attribute `if="$variable"` (mit Dollar)
+
+### Schritt 2: ErrorRendererFactory erweitern
+4. **createHttpRenderer() Methode hinzufügen**
+   - Parameter: `?bool $debugMode = null`
+   - Return: `ResponseErrorRenderer`
+   - Verwendet interne `engine` und `isDebugMode`
+
+### Schritt 3: Reflection entfernen
+5. **ErrorKernel::createHttpResponse() refactoren**
+   - Reflection-Code entfernen
+   - Factory-Methode `createHttpRenderer()` verwenden
+   - Type-Checking beibehalten
+
+### Schritt 4: ConsoleOutput optimieren
+6. **ExceptionHandlingInitializer anpassen**
+   - ConsoleOutput nur bei CLI-Context erstellen
+   - ErrorRendererFactory-Binding anpassen (null für HTTP-Context)
+
+7. **ConsoleErrorRenderer anpassen** (falls nötig)
+   - Null-Check für ConsoleOutput hinzufügen
+
+### Schritt 5: Fehlerbehandlung verbessern
+8. **ResponseErrorRenderer::renderWithTemplate() verbessern**
+   - Logging bei Template-Fehlern
+   - Spezifischere Exception-Typen
+   - Bessere Fehlermeldungen
+
+9. **Fallback HTML verbessern**
+   - HTML-Encoding für alle Variablen
+   - Debug-Informationen nur bei Debug-Mode
+   - Konsistente Formatierung
+
+### Schritt 6: Testing & Validierung
+10. **Template-Syntax testen**
+    - Alle Templates kompilieren lassen
+    - Variable-Substitution mit PHP-Syntax testen (`{{ $variable }}`)
+    - Array-Zugriff testen (`{{ $data['key'] }}`)
+    - Verschachtelte Array-Zugriffe testen (`{{ $data['debug']['file'] }}`)
+    - If-Bedingungen mit Dollar-Syntax testen (`if="$variable"`)
+
+11. **Reflection-Entfernung testen**
+    - createHttpResponse() mit verschiedenen Debug-Modes testen
+    - Sicherstellen, dass keine Reflection mehr verwendet wird
+
+12. **ConsoleOutput Optimierung testen**
+    - CLI-Context: ConsoleOutput verfügbar
+    - HTTP-Context: ConsoleOutput nicht erstellt
+
+## Dateien zu ändern
+
+### Templates:
+- `resources/views/errors/error.view.php` - Variable & If-Syntax (PHP-Syntax)
+- `resources/views/errors/404.view.php` - Variable-Syntax (PHP-Syntax, falls vorhanden)
+- `resources/views/errors/500.view.php` - Variable & If-Syntax (PHP-Syntax)
+
+### PHP-Klassen:
+- `src/Framework/ExceptionHandling/ErrorRendererFactory.php` - createHttpRenderer() Methode
+- `src/Framework/ExceptionHandling/ErrorKernel.php` - Reflection entfernen
+- `src/Framework/ExceptionHandling/ExceptionHandlingInitializer.php` - ConsoleOutput optimieren
+- `src/Framework/ExceptionHandling/Renderers/ResponseErrorRenderer.php` - Fehlerbehandlung verbessern
+
+## Wichtige Hinweise zur Template-Syntax
+
+**Variable-Syntax (PHP-Stil)**:
+- Einfache Variablen: `{{ $title }}`
+- Array-Zugriff: `{{ $data['title'] }}`
+- Verschachtelte Arrays: `{{ $data['debug']['file'] }}`
+- Object-Zugriff (falls Objekte): `{{ $object->property }}`
+
+**If-Bedingungen**:
+- Einfache Bedingung: `if="$isDebugMode"`
+- Negation: `if="!$isDebugMode"`
+- Array-Zugriff: `if="$debug"`
+- Verschachtelt: `if="$data['debug']"`
+
+**Template-Daten-Struktur**:
+Die Daten werden im `RenderContext` als `data` Array übergeben, daher:
+- `$title` entspricht `$data['title']` im Template
+- `$debug['file']` entspricht `$data['debug']['file']` im Template
+
+## Vorteile
+
+✅ **Konsistente Template-Syntax**: Verwendet PHP-Stil `{{ $variable }}`
+✅ **Keine Reflection**: Sauberer Code, bessere Performance
+✅ **Optimierte Ressourcennutzung**: ConsoleOutput nur bei Bedarf
+✅ **HTML-Attribut-Syntax**: Kompatibel mit Framework Template-System
+✅ **Robustere Fehlerbehandlung**: Besseres Logging und Fallbacks
+
+## Risiken & Nebenwirkungen
+
+⚠️ **Template-Syntax-Änderung**: Alle Error-Templates müssen angepasst werden
+⚠️ **If-Syntax-Änderung**: Bedingte Blöcke müssen auf HTML-Attribute umgestellt werden
+⚠️ **ConsoleOutput**: Null-Checks müssen bei Verwendung hinzugefügt werden
+
+## Validierung
+
+Nach Implementierung:
+- [ ] Alle Templates kompilieren ohne Fehler
+- [ ] Variable-Substitution mit PHP-Syntax funktioniert (`{{ $variable }}`)
+- [ ] Array-Zugriff funktioniert (`{{ $data['key'] }}`)
+- [ ] Verschachtelte Array-Zugriffe funktionieren (`{{ $data['debug']['file'] }}`)
+- [ ] If-Bedingungen funktionieren mit HTML-Attributen und Dollar-Syntax (`if="$variable"`)
+- [ ] Keine Reflection mehr in ErrorKernel
+- [ ] ConsoleOutput nur bei CLI-Context erstellt
+- [ ] Fallback HTML funktioniert korrekt
+